home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 42 / Amiga Format AFCD42 (Issue 126, Aug 1999).iso / -serious- / programming / other / jikes / src / error.cpp < prev    next >
C/C++ Source or Header  |  1999-05-14  |  127KB  |  4,214 lines
  1. // $Id: error.cpp,v 1.17 1999/03/10 19:59:21 shields Exp $
  2. //
  3. // This software is subject to the terms of the IBM Jikes Compiler
  4. // License Agreement available at the following URL:
  5. // http://www.ibm.com/research/jikes.
  6. // Copyright (C) 1996, 1998, International Business Machines Corporation
  7. // and others.  All Rights Reserved.
  8. // You must accept the terms of that agreement to use this software.
  9. //
  10. #include "config.h"
  11. #include <sys/stat.h>
  12. #include "unicode.h"
  13. #include "error.h"
  14. #include "control.h"
  15. #include "semantic.h"
  16. #include "ast.h"
  17.  
  18. unsigned char SemanticError::warning[SemanticError::_num_kinds] = { 0 };
  19. void (*SemanticError::print_message[SemanticError::_num_kinds]) (SemanticError::ErrorInfo &, LexStream *, Control &) = { NULL };
  20.  
  21. SemanticError::SemanticError(Control &control_, FileSymbol *file_symbol) : control(control_),
  22.                                                                            lex_stream(file_symbol -> lex_stream),
  23.  
  24.                                                                            buffer(1024),
  25.                                                                            error(512),
  26.                                                                            clone_count(0),
  27.                                                                            num_errors(0),
  28.                                                                            num_warnings(0)
  29. {}
  30.  
  31. //
  32. // This procedure is invoked by an JIKES PARSER or a semantic
  33. // routine to process an error message.  The JIKES parser always
  34. // passes the value 0 to msg_level to indicate an error.
  35. // This routine simply stores all necessary information about
  36. // the message into an array: error.
  37. //
  38. void SemanticError::Report(SemanticErrorKind msg_code,
  39.                            LexStream::TokenIndex left_token,
  40.                            LexStream::TokenIndex right_token,
  41.                            wchar_t *insert1,
  42.                            wchar_t *insert2,
  43.                            wchar_t *insert3,
  44.                            wchar_t *insert4,
  45.                            wchar_t *insert5,
  46.                            wchar_t *insert6,
  47.                            wchar_t *insert7,
  48.                            wchar_t *insert8,
  49.                            wchar_t *insert9)
  50. {
  51.     if (clone_count > 0) // do not report errors detected while processing a clone !!!
  52.         return;
  53.  
  54.     int i = error.NextIndex();
  55.  
  56.     if (warning[msg_code] > 0)
  57.          num_warnings++;
  58.     else num_errors++;
  59.  
  60.     error[i].msg_code = msg_code;
  61.  
  62.     int total_length = 0,
  63.         length1,
  64.         length2,
  65.         length3,
  66.         length4,
  67.         length5,
  68.         length6,
  69.         length7,
  70.         length8,
  71.         length9;
  72.  
  73.     if (insert1)
  74.     {
  75.         length1 = wcslen(insert1);
  76.         total_length += (length1 + 1);
  77.     }
  78.     else error[i].insert1 = NULL;
  79.  
  80.     if (insert2)
  81.     {
  82.         length2 = wcslen(insert2);
  83.         total_length += (length2 + 1);
  84.     }
  85.     else error[i].insert2 = NULL;
  86.  
  87.     if (insert3)
  88.     {
  89.         length3 = wcslen(insert3);
  90.         total_length += (length3 + 1);
  91.     }
  92.     else error[i].insert3 = NULL;
  93.  
  94.     if (insert4)
  95.     {
  96.         length4 = wcslen(insert4);
  97.         total_length += (length4 + 1);
  98.     }
  99.     else error[i].insert4 = NULL;
  100.  
  101.     if (insert5)
  102.     {
  103.         length5 = wcslen(insert5);
  104.         total_length += (length5 + 1);
  105.     }
  106.     else error[i].insert5 = NULL;
  107.  
  108.     if (insert6)
  109.     {
  110.         length6 = wcslen(insert6);
  111.         total_length += (length6 + 1);
  112.     }
  113.     else error[i].insert6 = NULL;
  114.  
  115.     if (insert7)
  116.     {
  117.         length7 = wcslen(insert7);
  118.         total_length += (length7 + 1);
  119.     }
  120.     else error[i].insert7 = NULL;
  121.  
  122.     if (insert8)
  123.     {
  124.         length8 = wcslen(insert8);
  125.         total_length += (length8 + 1);
  126.     }
  127.     else error[i].insert8 = NULL;
  128.  
  129.     if (insert9)
  130.     {
  131.         length9 = wcslen(insert9);
  132.         total_length += (length9 + 1);
  133.     }
  134.     else error[i].insert9 = NULL;
  135.  
  136.     if (total_length > 0)
  137.     {
  138.         wchar_t *ptr = new wchar_t[total_length];
  139.         buffer.Next() = ptr;
  140.  
  141.         if (insert1)
  142.         {
  143.             memmove(ptr, insert1, length1 * sizeof(wchar_t));
  144.             error[i].insert1 = ptr;
  145.             ptr += length1;
  146.             *ptr++ = U_NULL;
  147.         }
  148.  
  149.         if (insert2)
  150.         {
  151.             memmove(ptr, insert2, length2 * sizeof(wchar_t));
  152.             error[i].insert2 = ptr;
  153.             ptr += length2;
  154.             *ptr++ = U_NULL;
  155.         }
  156.  
  157.         if (insert3)
  158.         {
  159.             memmove(ptr, insert3, length3 * sizeof(wchar_t));
  160.             error[i].insert3 = ptr;
  161.             ptr += length3;
  162.             *ptr++ = U_NULL;
  163.         }
  164.  
  165.         if (insert4)
  166.         {
  167.             memmove(ptr, insert4, length4 * sizeof(wchar_t));
  168.             error[i].insert4 = ptr;
  169.             ptr += length4;
  170.             *ptr++ = U_NULL;
  171.         }
  172.  
  173.         if (insert5)
  174.         {
  175.             memmove(ptr, insert5, length5 * sizeof(wchar_t));
  176.             error[i].insert5 = ptr;
  177.             ptr += length5;
  178.             *ptr++ = U_NULL;
  179.         }
  180.  
  181.         if (insert6)
  182.         {
  183.             memmove(ptr, insert6, length6 * sizeof(wchar_t));
  184.             error[i].insert6 = ptr;
  185.             ptr += length6;
  186.             *ptr++ = U_NULL;
  187.         }
  188.  
  189.         if (insert7)
  190.         {
  191.             memmove(ptr, insert7, length7 * sizeof(wchar_t));
  192.             error[i].insert7 = ptr;
  193.             ptr += length7;
  194.             *ptr++ = U_NULL;
  195.         }
  196.  
  197.         if (insert8)
  198.         {
  199.             memmove(ptr, insert8, length8 * sizeof(wchar_t));
  200.             error[i].insert8 = ptr;
  201.             ptr += length8;
  202.             *ptr++ = U_NULL;
  203.         }
  204.  
  205.         if (insert9)
  206.         {
  207.             memmove(ptr, insert9, length9 * sizeof(wchar_t));
  208.             error[i].insert9 = ptr;
  209.             ptr += length9;
  210.             *ptr++ = U_NULL;
  211.         }
  212.     }
  213.  
  214.     error[i].num         = i;
  215.     error[i].left_token  = (left_token > right_token ? right_token : left_token);
  216.     error[i].right_token = right_token;
  217.     error[i].right_string_length = lex_stream -> NameLength(right_token);
  218.  
  219.     //
  220.     // Dump the error immediately ?
  221.     //
  222.     if (control.option.dump_errors)
  223.     {
  224.         PrintEmacsMessage(i);
  225.  
  226.         if (buffer.Length() > 0)
  227.         {
  228.             delete [] buffer[0];
  229.             buffer.Reset();
  230.         }
  231.         error.Reset(1); // we need at least 1 error in order for the return code to be set properly. See print_messages
  232.         cout.flush();
  233.     }
  234.  
  235.     return;
  236. }
  237.  
  238. void SemanticError::StaticInitializer()
  239. {
  240.     memset(warning, 0, _num_kinds * sizeof(bool));
  241.  
  242.     warning[INVALID_OPTION] = 1;
  243.     warning[CANNOT_OPEN_ZIP_FILE] = 1;
  244.  
  245.     warning[EMPTY_DECLARATION] = 1;
  246.     warning[REDUNDANT_ABSTRACT] = 1;
  247.     warning[REDUNDANT_FINAL] = 1;
  248.     warning[REDUNDANT_PUBLIC] = 1;
  249.     warning[REDUNDANT_STATIC] = 1;
  250.     warning[OBSOLESCENT_ABSTRACT] = 1;
  251.     warning[OBSOLESCENT_BRACKETS] = 1;
  252.     warning[NO_TYPES] = 1;
  253.     warning[PARENT_TYPE_IN_UNNAMED_PACKAGE] = 1;
  254.  
  255.     warning[MULTIPLE_PUBLIC_TYPES] = 1;
  256.     warning[TYPE_IN_MULTIPLE_FILES] = 1;
  257.     warning[MISMATCHED_TYPE_AND_FILE_NAMES] = 1;
  258.     warning[REFERENCE_TO_TYPE_IN_MISMATCHED_FILE] = 1;
  259.     warning[ONE_UNNAMED_PACKAGE] = 1;
  260.     warning[RECOMPILATION] = 1;
  261.     warning[METHOD_WITH_CONSTRUCTOR_NAME] = 1;
  262.  
  263.     warning[DEFAULT_METHOD_NOT_OVERRIDDEN] = 1;
  264.  
  265.     //
  266.     // TODO: Review the cases below. They should be flagged as errors.
  267.     //       However, since javac does not flag them at all, we only issue
  268.     //       a warning.
  269.     warning[INHERITANCE_AND_LEXICAL_SCOPING_CONFLICT_WITH_LOCAL] = 2;
  270.     warning[INHERITANCE_AND_LEXICAL_SCOPING_CONFLICT_WITH_MEMBER] = 2;
  271.     warning[PRIVATE_METHOD_OVERRIDE] = 1;
  272.     warning[PRIVATE_METHOD_OVERRIDE_EXTERNALLY] = 1;
  273.  
  274.     //
  275.     // Something stronger than a warning, but code will be generated anyway
  276.     //
  277.     warning[BAD_INPUT_FILE] = 2;
  278.     warning[UNREADABLE_INPUT_FILE] = 2;
  279.  
  280. //
  281. // TODO: Let these conditions be flagged as errors now.
  282. //
  283. //    warning[UNREACHABLE_CATCH_CLAUSE] = 2;
  284. //    warning[VARIABLE_NOT_DEFINITELY_ASSIGNED] = 2;
  285. //    warning[TARGET_VARIABLE_IS_FINAL] = 2;
  286. //    warning[FINAL_VARIABLE_TARGET_IN_LOOP] = 2;
  287. //    warning[VOID_TO_STRING] = 2;
  288. //
  289.  
  290. #ifdef TEST
  291.     for (int i = 0; i < _num_kinds; i++)
  292.         print_message[i] = NULL;
  293. #endif
  294.  
  295.     print_message[BAD_ERROR] = PrintBAD_ERROR;
  296.     print_message[DEFAULT_ERROR] = PrintDEFAULT_ERROR;
  297.     print_message[INVALID_OPTION] = PrintINVALID_OPTION;
  298.     print_message[INVALID_K_OPTION] = PrintINVALID_K_OPTION;
  299.     print_message[INVALID_K_TARGET] = PrintINVALID_K_TARGET;
  300.     print_message[INVALID_TAB_VALUE] = PrintINVALID_TAB_VALUE;
  301.     print_message[INVALID_DIRECTORY] = PrintINVALID_DIRECTORY;
  302.     print_message[UNSUPPORTED_OPTION] = PrintUNSUPPORTED_OPTION;
  303.     print_message[NO_CURRENT_DIRECTORY] = PrintNO_CURRENT_DIRECTORY;
  304.     print_message[CANNOT_OPEN_ZIP_FILE] = PrintCANNOT_OPEN_ZIP_FILE;
  305.     print_message[PACKAGE_NOT_FOUND] = PrintPACKAGE_NOT_FOUND;
  306.     print_message[CANNOT_OPEN_DIRECTORY] = PrintCANNOT_OPEN_DIRECTORY;
  307.     print_message[BAD_INPUT_FILE] = PrintBAD_INPUT_FILE;
  308.     print_message[UNREADABLE_INPUT_FILE] = PrintUNREADABLE_INPUT_FILE;
  309.     print_message[CANNOT_REOPEN_FILE] = PrintCANNOT_REOPEN_FILE;
  310.     print_message[CANNOT_WRITE_FILE] = PrintCANNOT_WRITE_FILE;
  311.     print_message[CANNOT_COMPUTE_COLUMNS] = PrintCANNOT_COMPUTE_COLUMNS;
  312.     print_message[EMPTY_DECLARATION] = PrintEMPTY_DECLARATION;
  313.     print_message[REDUNDANT_ABSTRACT] = PrintREDUNDANT_ABSTRACT;
  314.     print_message[REDUNDANT_FINAL] = PrintREDUNDANT_FINAL;
  315.     print_message[REDUNDANT_PUBLIC] = PrintREDUNDANT_PUBLIC;
  316.     print_message[REDUNDANT_STATIC] = PrintREDUNDANT_STATIC;
  317.     print_message[OBSOLESCENT_ABSTRACT] = PrintOBSOLESCENT_ABSTRACT;
  318.     print_message[OBSOLESCENT_BRACKETS] = PrintOBSOLESCENT_BRACKETS;
  319.     print_message[NO_TYPES] = PrintNO_TYPES;
  320.     print_message[MULTIPLE_PUBLIC_TYPES] = PrintMULTIPLE_PUBLIC_TYPES;
  321.     print_message[TYPE_IN_MULTIPLE_FILES] = PrintTYPE_IN_MULTIPLE_FILES;
  322.     print_message[PACKAGE_TYPE_CONFLICT] = PrintPACKAGE_TYPE_CONFLICT;
  323.     print_message[DIRECTORY_FILE_CONFLICT] = PrintDIRECTORY_FILE_CONFLICT;
  324.     print_message[FILE_FILE_CONFLICT] = PrintFILE_FILE_CONFLICT;
  325.     print_message[MISMATCHED_TYPE_AND_FILE_NAMES] = PrintMISMATCHED_TYPE_AND_FILE_NAMES;
  326.     print_message[REFERENCE_TO_TYPE_IN_MISMATCHED_FILE] = PrintREFERENCE_TO_TYPE_IN_MISMATCHED_FILE;
  327.     print_message[DUPLICATE_INNER_TYPE_NAME] = PrintDUPLICATE_INNER_TYPE_NAME;
  328.     print_message[DUPLICATE_TYPE_DECLARATION] = PrintDUPLICATE_TYPE_DECLARATION;
  329.     print_message[DUPLICATE_ACCESS_MODIFIER] = PrintDUPLICATE_ACCESS_MODIFIER;
  330.     print_message[DUPLICATE_MODIFIER] = PrintDUPLICATE_MODIFIER;
  331.     print_message[FINAL_ABSTRACT_CLASS] = PrintFINAL_ABSTRACT_CLASS;
  332.     print_message[VOLATILE_FINAL] = PrintVOLATILE_FINAL;
  333.     print_message[FINAL_VOLATILE] = PrintFINAL_VOLATILE;
  334.     print_message[INVALID_TOP_LEVEL_CLASS_MODIFIER] = PrintINVALID_TOP_LEVEL_CLASS_MODIFIER;
  335.     print_message[INVALID_INNER_CLASS_MODIFIER] = PrintINVALID_INNER_CLASS_MODIFIER;
  336.     print_message[INVALID_STATIC_INNER_CLASS_MODIFIER] = PrintINVALID_STATIC_INNER_CLASS_MODIFIER;
  337.     print_message[INVALID_LOCAL_CLASS_MODIFIER] = PrintINVALID_LOCAL_CLASS_MODIFIER;
  338.     print_message[INVALID_INTERFACE_MODIFIER] = PrintINVALID_INTERFACE_MODIFIER;
  339.     print_message[INVALID_FIELD_MODIFIER] = PrintINVALID_FIELD_MODIFIER;
  340.     print_message[INVALID_LOCAL_MODIFIER] = PrintINVALID_LOCAL_MODIFIER;
  341.     print_message[INVALID_METHOD_MODIFIER] = PrintINVALID_METHOD_MODIFIER;
  342.     print_message[INVALID_SIGNATURE_MODIFIER] = PrintINVALID_SIGNATURE_MODIFIER;
  343.     print_message[INVALID_CONSTRUCTOR_MODIFIER] = PrintINVALID_CONSTRUCTOR_MODIFIER;
  344.     print_message[INVALID_CONSTANT_MODIFIER] = PrintINVALID_CONSTANT_MODIFIER;
  345.     print_message[UNINITIALIZED_FIELD] = PrintUNINITIALIZED_FIELD;
  346.     print_message[PARENT_TYPE_IN_UNNAMED_PACKAGE] = PrintPARENT_TYPE_IN_UNNAMED_PACKAGE;
  347.     print_message[RECOMPILATION] = PrintRECOMPILATION;
  348.     print_message[TYPE_NOT_FOUND] = PrintTYPE_NOT_FOUND;
  349.     print_message[DUPLICATE_ON_DEMAND_IMPORT] = PrintDUPLICATE_ON_DEMAND_IMPORT;
  350.     print_message[NOT_A_TYPE] = PrintNOT_A_TYPE;
  351.     print_message[NOT_A_CLASS] = PrintNOT_A_CLASS;
  352.     print_message[NOT_AN_INTERFACE] = PrintNOT_AN_INTERFACE;
  353.     print_message[SUPER_IS_FINAL] = PrintSUPER_IS_FINAL;
  354.     print_message[OBJECT_WITH_SUPER_TYPE] = PrintOBJECT_WITH_SUPER_TYPE;
  355.     print_message[OBJECT_HAS_NO_SUPER_TYPE] = PrintOBJECT_HAS_NO_SUPER_TYPE;
  356.     print_message[DUPLICATE_FIELD] = PrintDUPLICATE_FIELD;
  357.     print_message[DUPLICATE_METHOD] = PrintDUPLICATE_METHOD;
  358.     print_message[DUPLICATE_CONSTRUCTOR] = PrintDUPLICATE_CONSTRUCTOR;
  359.     print_message[MISMATCHED_INHERITED_METHOD] = PrintMISMATCHED_INHERITED_METHOD;
  360.     print_message[MISMATCHED_INHERITED_METHOD_EXTERNALLY] = PrintMISMATCHED_INHERITED_METHOD_EXTERNALLY;
  361.     print_message[DUPLICATE_FORMAL_PARAMETER] = PrintDUPLICATE_FORMAL_PARAMETER;
  362.     print_message[MISMATCHED_CONSTRUCTOR_NAME] = PrintMISMATCHED_CONSTRUCTOR_NAME;
  363.     print_message[METHOD_WITH_CONSTRUCTOR_NAME] = PrintMETHOD_WITH_CONSTRUCTOR_NAME;
  364.     print_message[DUPLICATE_LOCAL_VARIABLE_DECLARATION] = PrintDUPLICATE_LOCAL_VARIABLE_DECLARATION;
  365.     print_message[DUPLICATE_LOCAL_TYPE_DECLARATION] = PrintDUPLICATE_LOCAL_TYPE_DECLARATION;
  366.     print_message[MULTIPLE_DEFAULT_LABEL] = PrintMULTIPLE_DEFAULT_LABEL;
  367.     print_message[UNDECLARED_LABEL] = PrintUNDECLARED_LABEL;
  368.     print_message[DUPLICATE_LABEL] = PrintDUPLICATE_LABEL;
  369.     print_message[CATCH_PRIMITIVE_TYPE] = PrintCATCH_PRIMITIVE_TYPE;
  370.     print_message[CATCH_ARRAY_TYPE] = PrintCATCH_ARRAY_TYPE;
  371.     print_message[AMBIGUOUS_NAME] = PrintAMBIGUOUS_NAME;
  372.     print_message[FIELD_IS_TYPE] = PrintFIELD_IS_TYPE;
  373.     print_message[FIELD_NOT_FOUND] = PrintFIELD_NOT_FOUND;
  374.     print_message[FIELD_NAME_MISSPELLED] = PrintFIELD_NAME_MISSPELLED;
  375.     print_message[FIELD_WITH_PRIVATE_ACCESS_NOT_ACCESSIBLE] = PrintFIELD_WITH_PRIVATE_ACCESS_NOT_ACCESSIBLE;
  376.     print_message[FIELD_WITH_DEFAULT_ACCESS_NOT_ACCESSIBLE] = PrintFIELD_WITH_DEFAULT_ACCESS_NOT_ACCESSIBLE;
  377.     print_message[NAME_NOT_FOUND] = PrintNAME_NOT_FOUND;
  378.     print_message[METHOD_NOT_FIELD] = PrintMETHOD_NOT_FIELD;
  379.     print_message[NAME_NOT_YET_AVAILABLE] = PrintNAME_NOT_YET_AVAILABLE;
  380.     print_message[NAME_NOT_VARIABLE] = PrintNAME_NOT_VARIABLE;
  381.     print_message[NAME_NOT_CLASS_VARIABLE] = PrintNAME_NOT_CLASS_VARIABLE;
  382.     print_message[NOT_A_NUMERIC_VARIABLE] = PrintNOT_A_NUMERIC_VARIABLE;
  383.     print_message[METHOD_NOT_FOUND] = PrintMETHOD_NOT_FOUND;
  384.     print_message[METHOD_NAME_NOT_FOUND_IN_TYPE] = PrintMETHOD_NAME_NOT_FOUND_IN_TYPE;
  385.     print_message[METHOD_NAME_MISSPELLED] = PrintMETHOD_NAME_MISSPELLED;
  386.     print_message[METHOD_WITH_PRIVATE_ACCESS_NOT_ACCESSIBLE] = PrintMETHOD_WITH_PRIVATE_ACCESS_NOT_ACCESSIBLE;
  387.     print_message[METHOD_WITH_DEFAULT_ACCESS_NOT_ACCESSIBLE] = PrintMETHOD_WITH_DEFAULT_ACCESS_NOT_ACCESSIBLE;
  388.     print_message[HIDDEN_METHOD_IN_ENCLOSING_CLASS] = PrintHIDDEN_METHOD_IN_ENCLOSING_CLASS;
  389.     print_message[FIELD_NOT_METHOD] = PrintFIELD_NOT_METHOD;
  390.     print_message[TYPE_NOT_METHOD] = PrintTYPE_NOT_METHOD;
  391.     print_message[TYPE_NOT_FIELD] = PrintTYPE_NOT_FIELD;
  392.     print_message[METHOD_NOT_CLASS_METHOD] = PrintMETHOD_NOT_CLASS_METHOD;
  393.     print_message[AMBIGUOUS_CONSTRUCTOR_INVOCATION] = PrintAMBIGUOUS_CONSTRUCTOR_INVOCATION;
  394.     print_message[AMBIGUOUS_METHOD_INVOCATION] = PrintAMBIGUOUS_METHOD_INVOCATION;
  395.     print_message[CONSTRUCTOR_NOT_FOUND] = PrintCONSTRUCTOR_NOT_FOUND;
  396.     print_message[METHOD_FOUND_FOR_CONSTRUCTOR] = PrintMETHOD_FOUND_FOR_CONSTRUCTOR;
  397.     print_message[ABSTRACT_TYPE_CREATION] = PrintABSTRACT_TYPE_CREATION;
  398.     print_message[INVALID_INSTANCEOF_CONVERSION] = PrintINVALID_INSTANCEOF_CONVERSION;
  399.     print_message[INVALID_CAST_CONVERSION] = PrintINVALID_CAST_CONVERSION;
  400.     print_message[INVALID_CAST_TYPE] = PrintINVALID_CAST_TYPE;
  401.     print_message[INCOMPATIBLE_TYPE_FOR_INITIALIZATION] = PrintINCOMPATIBLE_TYPE_FOR_INITIALIZATION;
  402.     print_message[INCOMPATIBLE_TYPE_FOR_ASSIGNMENT] = PrintINCOMPATIBLE_TYPE_FOR_ASSIGNMENT;
  403.     print_message[INCOMPATIBLE_TYPE_FOR_BINARY_EXPRESSION] = PrintINCOMPATIBLE_TYPE_FOR_BINARY_EXPRESSION;
  404.     print_message[INCOMPATIBLE_TYPE_FOR_CONDITIONAL_EXPRESSION] = PrintINCOMPATIBLE_TYPE_FOR_CONDITIONAL_EXPRESSION;
  405.     print_message[VOID_ARRAY] = PrintVOID_ARRAY;
  406.     print_message[VOID_TYPE_IN_EQUALITY_EXPRESSION] = PrintVOID_TYPE_IN_EQUALITY_EXPRESSION;
  407.     print_message[TYPE_NOT_THROWABLE] = PrintTYPE_NOT_THROWABLE;
  408.     print_message[TYPE_NOT_PRIMITIVE] = PrintTYPE_NOT_PRIMITIVE;
  409.     print_message[TYPE_NOT_INTEGRAL] = PrintTYPE_NOT_INTEGRAL;
  410.     print_message[TYPE_NOT_NUMERIC] = PrintTYPE_NOT_NUMERIC;
  411.     print_message[TYPE_NOT_INTEGER] = PrintTYPE_NOT_INTEGER;
  412.     print_message[TYPE_NOT_BOOLEAN] = PrintTYPE_NOT_BOOLEAN;
  413.     print_message[TYPE_NOT_ARRAY] = PrintTYPE_NOT_ARRAY;
  414.     print_message[TYPE_NOT_REFERENCE] = PrintTYPE_NOT_REFERENCE;
  415.     print_message[TYPE_NOT_VALID_FOR_SWITCH] = PrintTYPE_NOT_VALID_FOR_SWITCH;
  416.     print_message[TYPE_IS_VOID] = PrintTYPE_IS_VOID;
  417.     print_message[VALUE_NOT_REPRESENTABLE_IN_TYPE] = PrintVALUE_NOT_REPRESENTABLE_IN_TYPE;
  418.     print_message[DUPLICATE_CASE_VALUE] = PrintDUPLICATE_CASE_VALUE;
  419.     print_message[MISPLACED_THIS_EXPRESSION] = PrintMISPLACED_THIS_EXPRESSION;
  420.     print_message[MISPLACED_SUPER_EXPRESSION] = PrintMISPLACED_SUPER_EXPRESSION;
  421.     print_message[TARGET_VARIABLE_IS_FINAL] = PrintTARGET_VARIABLE_IS_FINAL;
  422.     print_message[FINAL_VARIABLE_TARGET_IN_LOOP] = PrintFINAL_VARIABLE_TARGET_IN_LOOP;
  423.     print_message[UNINITIALIZED_FINAL_VARIABLE] = PrintUNINITIALIZED_FINAL_VARIABLE;
  424.     print_message[UNINITIALIZED_STATIC_FINAL_VARIABLE] = PrintUNINITIALIZED_STATIC_FINAL_VARIABLE;
  425.     print_message[UNINITIALIZED_FINAL_VARIABLE_IN_CONSTRUCTOR] = PrintUNINITIALIZED_FINAL_VARIABLE_IN_CONSTRUCTOR;
  426.     print_message[INIT_SCALAR_WITH_ARRAY] = PrintINIT_SCALAR_WITH_ARRAY;
  427.     print_message[INIT_ARRAY_WITH_SCALAR] = PrintINIT_ARRAY_WITH_SCALAR;
  428.     print_message[INVALID_BYTE_VALUE] = PrintINVALID_BYTE_VALUE;
  429.     print_message[INVALID_SHORT_VALUE] = PrintINVALID_SHORT_VALUE;
  430.     print_message[INVALID_CHARACTER_VALUE] = PrintINVALID_CHARACTER_VALUE;
  431.     print_message[INVALID_INT_VALUE] = PrintINVALID_INT_VALUE;
  432.     print_message[INVALID_LONG_VALUE] = PrintINVALID_LONG_VALUE;
  433.     print_message[INVALID_FLOAT_VALUE] = PrintINVALID_FLOAT_VALUE;
  434.     print_message[INVALID_DOUBLE_VALUE] = PrintINVALID_DOUBLE_VALUE;
  435.     print_message[INVALID_STRING_VALUE] = PrintINVALID_STRING_VALUE;
  436.     print_message[RETURN_STATEMENT_IN_INITIALIZER] = PrintRETURN_STATEMENT_IN_INITIALIZER;
  437.     print_message[MISPLACED_RETURN_WITH_EXPRESSION] = PrintMISPLACED_RETURN_WITH_EXPRESSION;
  438.     print_message[MISPLACED_RETURN_WITH_NO_EXPRESSION] = PrintMISPLACED_RETURN_WITH_NO_EXPRESSION;
  439.     print_message[MISMATCHED_RETURN_AND_METHOD_TYPE] = PrintMISMATCHED_RETURN_AND_METHOD_TYPE;
  440.     print_message[EXPRESSION_NOT_THROWABLE] = PrintEXPRESSION_NOT_THROWABLE;
  441.     print_message[BAD_THROWABLE_EXPRESSION_IN_TRY] = PrintBAD_THROWABLE_EXPRESSION_IN_TRY;
  442.     print_message[BAD_THROWABLE_EXPRESSION_IN_METHOD] = PrintBAD_THROWABLE_EXPRESSION_IN_METHOD;
  443.     print_message[BAD_THROWABLE_EXPRESSION] = PrintBAD_THROWABLE_EXPRESSION;
  444.     print_message[MISPLACED_BREAK_STATEMENT] = PrintMISPLACED_BREAK_STATEMENT;
  445.     print_message[MISPLACED_CONTINUE_STATEMENT] = PrintMISPLACED_CONTINUE_STATEMENT;
  446.     print_message[MISPLACED_EXPLICIT_CONSTRUCTOR_INVOCATION] = PrintMISPLACED_EXPLICIT_CONSTRUCTOR_INVOCATION;
  447.     print_message[INVALID_CONTINUE_TARGET] = PrintINVALID_CONTINUE_TARGET;
  448.     print_message[NON_ABSTRACT_TYPE_CONTAINS_ABSTRACT_METHOD] = PrintNON_ABSTRACT_TYPE_CONTAINS_ABSTRACT_METHOD;
  449.     print_message[NON_ABSTRACT_TYPE_INHERITS_ABSTRACT_METHOD] = PrintNON_ABSTRACT_TYPE_INHERITS_ABSTRACT_METHOD;
  450.     print_message[NON_ABSTRACT_TYPE_INHERITS_ABSTRACT_METHOD_FROM_ABSTRACT_CLASS] = PrintNON_ABSTRACT_TYPE_INHERITS_ABSTRACT_METHOD_FROM_ABSTRACT_CLASS;
  451.     print_message[NON_ABSTRACT_TYPE_CANNOT_OVERRIDE_DEFAULT_ABSTRACT_METHOD] = PrintNON_ABSTRACT_TYPE_CANNOT_OVERRIDE_DEFAULT_ABSTRACT_METHOD;
  452.     print_message[NO_ABSTRACT_METHOD_IMPLEMENTATION] = PrintNO_ABSTRACT_METHOD_IMPLEMENTATION;
  453.     print_message[DUPLICATE_INTERFACE] = PrintDUPLICATE_INTERFACE;
  454.     print_message[UNKNOWN_QUALIFIED_NAME_BASE] = PrintUNKNOWN_QUALIFIED_NAME_BASE;
  455.     print_message[UNKNOWN_AMBIGUOUS_NAME] = PrintUNKNOWN_AMBIGUOUS_NAME;
  456.     print_message[CIRCULAR_INTERFACE] = PrintCIRCULAR_INTERFACE;
  457.     print_message[CIRCULAR_CLASS] = PrintCIRCULAR_CLASS;
  458.     print_message[TYPE_NOT_ACCESSIBLE] = PrintTYPE_NOT_ACCESSIBLE;
  459.     print_message[PRIVATE_FIELD_NOT_ACCESSIBLE] = PrintPRIVATE_FIELD_NOT_ACCESSIBLE;
  460.     print_message[PROTECTED_FIELD_NOT_ACCESSIBLE] = PrintPROTECTED_FIELD_NOT_ACCESSIBLE;
  461.     print_message[DEFAULT_FIELD_NOT_ACCESSIBLE] = PrintDEFAULT_FIELD_NOT_ACCESSIBLE;
  462.     print_message[PRIVATE_METHOD_NOT_ACCESSIBLE] = PrintPRIVATE_METHOD_NOT_ACCESSIBLE;
  463.     print_message[PROTECTED_METHOD_NOT_ACCESSIBLE] = PrintPROTECTED_METHOD_NOT_ACCESSIBLE;
  464.     print_message[DEFAULT_METHOD_NOT_ACCESSIBLE] = PrintDEFAULT_METHOD_NOT_ACCESSIBLE;
  465.     print_message[PRIVATE_CONSTRUCTOR_NOT_ACCESSIBLE] = PrintPRIVATE_CONSTRUCTOR_NOT_ACCESSIBLE;
  466.     print_message[PROTECTED_CONSTRUCTOR_NOT_ACCESSIBLE] = PrintPROTECTED_CONSTRUCTOR_NOT_ACCESSIBLE;
  467.     print_message[DEFAULT_CONSTRUCTOR_NOT_ACCESSIBLE] = PrintDEFAULT_CONSTRUCTOR_NOT_ACCESSIBLE;
  468.     print_message[CONSTRUCTOR_DOES_NOT_THROW_THIS_EXCEPTION] = PrintCONSTRUCTOR_DOES_NOT_THROW_THIS_EXCEPTION;
  469.     print_message[CONSTRUCTOR_DOES_NOT_THROW_SUPER_EXCEPTION] = PrintCONSTRUCTOR_DOES_NOT_THROW_SUPER_EXCEPTION;
  470.     print_message[PARAMETER_REDECLARED] = PrintPARAMETER_REDECLARED;
  471.     print_message[BAD_ABSTRACT_METHOD_MODIFIER] = PrintBAD_ABSTRACT_METHOD_MODIFIER;
  472.     print_message[ABSTRACT_METHOD_MODIFIER_CONFLICT] = PrintABSTRACT_METHOD_MODIFIER_CONFLICT;
  473.     print_message[ABSTRACT_METHOD_INVOCATION] = PrintABSTRACT_METHOD_INVOCATION;
  474.     print_message[FINAL_METHOD_OVERRIDE] = PrintFINAL_METHOD_OVERRIDE;
  475.     print_message[FINAL_METHOD_OVERRIDE_EXTERNALLY] = PrintFINAL_METHOD_OVERRIDE_EXTERNALLY;
  476.     print_message[PRIVATE_METHOD_OVERRIDE] = PrintPRIVATE_METHOD_OVERRIDE;
  477.     print_message[PRIVATE_METHOD_OVERRIDE_EXTERNALLY] = PrintPRIVATE_METHOD_OVERRIDE_EXTERNALLY;
  478.     print_message[INSTANCE_METHOD_OVERRIDE] = PrintINSTANCE_METHOD_OVERRIDE;
  479.     print_message[INSTANCE_METHOD_OVERRIDE_EXTERNALLY] = PrintINSTANCE_METHOD_OVERRIDE_EXTERNALLY;
  480.     print_message[CLASS_METHOD_OVERRIDE] = PrintCLASS_METHOD_OVERRIDE;
  481.     print_message[CLASS_METHOD_OVERRIDE_EXTERNALLY] = PrintCLASS_METHOD_OVERRIDE_EXTERNALLY;
  482.     print_message[MISMATCHED_OVERRIDDEN_EXCEPTION] = PrintMISMATCHED_OVERRIDDEN_EXCEPTION;
  483.     print_message[MISMATCHED_OVERRIDDEN_EXCEPTION_EXTERNALLY] = PrintMISMATCHED_OVERRIDDEN_EXCEPTION_EXTERNALLY;
  484.     print_message[ABSTRACT_METHOD_WITH_BODY] = PrintABSTRACT_METHOD_WITH_BODY;
  485.     print_message[NON_ABSTRACT_METHOD_WITHOUT_BODY] = PrintNON_ABSTRACT_METHOD_WITHOUT_BODY;
  486.     print_message[BAD_ACCESS_METHOD_OVERRIDE] = PrintBAD_ACCESS_METHOD_OVERRIDE;
  487.     print_message[BAD_ACCESS_METHOD_OVERRIDE_EXTERNALLY] = PrintBAD_ACCESS_METHOD_OVERRIDE_EXTERNALLY;
  488.     print_message[STATIC_OVERRIDE_ABSTRACT] = PrintSTATIC_OVERRIDE_ABSTRACT;
  489.     print_message[STATIC_OVERRIDE_ABSTRACT_EXTERNALLY] = PrintSTATIC_OVERRIDE_ABSTRACT_EXTERNALLY;
  490.     print_message[CIRCULAR_THIS_CALL] = PrintCIRCULAR_THIS_CALL;
  491.     print_message[INSTANCE_VARIABLE_IN_EXPLICIT_CONSTRUCTOR_INVOCATION] = PrintINSTANCE_VARIABLE_IN_EXPLICIT_CONSTRUCTOR_INVOCATION;
  492.     print_message[INSTANCE_METHOD_IN_EXPLICIT_CONSTRUCTOR_INVOCATION] = PrintINSTANCE_METHOD_IN_EXPLICIT_CONSTRUCTOR_INVOCATION;
  493.     print_message[SYNTHETIC_VARIABLE_ACCESS] = PrintSYNTHETIC_VARIABLE_ACCESS;
  494.     print_message[SYNTHETIC_METHOD_INVOCATION] = PrintSYNTHETIC_METHOD_INVOCATION;
  495.     print_message[THIS_IN_EXPLICIT_CONSTRUCTOR_INVOCATION] = PrintTHIS_IN_EXPLICIT_CONSTRUCTOR_INVOCATION;
  496.     print_message[SUPER_IN_EXPLICIT_CONSTRUCTOR_INVOCATION] = PrintSUPER_IN_EXPLICIT_CONSTRUCTOR_INVOCATION;
  497.     print_message[EXPRESSION_NOT_CONSTANT] = PrintEXPRESSION_NOT_CONSTANT;
  498.     print_message[UNCATCHABLE_METHOD_THROWN_CHECKED_EXCEPTION] = PrintUNCATCHABLE_METHOD_THROWN_CHECKED_EXCEPTION;
  499.     print_message[UNCATCHABLE_CONSTRUCTOR_THROWN_CHECKED_EXCEPTION] = PrintUNCATCHABLE_CONSTRUCTOR_THROWN_CHECKED_EXCEPTION;
  500.     print_message[UNREACHABLE_CATCH_CLAUSE] = PrintUNREACHABLE_CATCH_CLAUSE;
  501.     print_message[UNREACHABLE_STATEMENT] = PrintUNREACHABLE_STATEMENT;
  502.     print_message[UNREACHABLE_STATEMENTS] = PrintUNREACHABLE_STATEMENTS;
  503.     print_message[UNREACHABLE_CONSTRUCTOR_BODY] = PrintUNREACHABLE_CONSTRUCTOR_BODY;
  504.     print_message[BLOCKED_CATCH_CLAUSE] = PrintBLOCKED_CATCH_CLAUSE;
  505.     print_message[VARIABLE_NOT_DEFINITELY_ASSIGNED] = PrintVARIABLE_NOT_DEFINITELY_ASSIGNED;
  506.     print_message[TYPED_METHOD_WITH_NO_RETURN] = PrintTYPED_METHOD_WITH_NO_RETURN;
  507.  
  508.     print_message[DEFAULT_METHOD_NOT_OVERRIDDEN] = PrintDEFAULT_METHOD_NOT_OVERRIDDEN;
  509.  
  510.     print_message[ONE_UNNAMED_PACKAGE] = PrintONE_UNNAMED_PACKAGE;
  511.     print_message[TYPE_NOT_IN_UNNAMED_PACKAGE] = PrintTYPE_NOT_IN_UNNAMED_PACKAGE;
  512.     print_message[TYPE_IN_WRONG_PACKAGE] = PrintTYPE_IN_WRONG_PACKAGE;
  513.     print_message[TYPE_NAME_MISMATCH] = PrintTYPE_NAME_MISMATCH;
  514.  
  515.     print_message[COMPRESSED_ZIP_FILE] = PrintCOMPRESSED_ZIP_FILE;
  516.     print_message[INVALID_CLASS_FILE] = PrintINVALID_CLASS_FILE;
  517.     print_message[CANNOT_OPEN_CLASS_FILE] = PrintCANNOT_OPEN_CLASS_FILE;
  518.  
  519.     print_message[ONE_ONE_FEATURE] = PrintONE_ONE_FEATURE;
  520.     print_message[STATIC_NOT_INNER_CLASS] = PrintSTATIC_NOT_INNER_CLASS;
  521.     print_message[TYPE_NOT_INNER_CLASS] = PrintTYPE_NOT_INNER_CLASS;
  522.     print_message[SUPER_TYPE_NOT_INNER_CLASS] = PrintSUPER_TYPE_NOT_INNER_CLASS;
  523.     print_message[STATIC_FIELD_IN_INNER_CLASS] = PrintSTATIC_FIELD_IN_INNER_CLASS;
  524.     print_message[STATIC_METHOD_IN_INNER_CLASS] = PrintSTATIC_METHOD_IN_INNER_CLASS;
  525.     print_message[STATIC_TYPE_IN_INNER_CLASS] = PrintSTATIC_TYPE_IN_INNER_CLASS;
  526.     print_message[STATIC_INITIALIZER_IN_INNER_CLASS] = PrintSTATIC_INITIALIZER_IN_INNER_CLASS;
  527.     print_message[INNER_CLASS_REFERENCE_TO_NON_FINAL_LOCAL_VARIABLE] = PrintINNER_CLASS_REFERENCE_TO_NON_FINAL_LOCAL_VARIABLE;
  528.     print_message[INHERITANCE_AND_LEXICAL_SCOPING_CONFLICT_WITH_LOCAL] = PrintINHERITANCE_AND_LEXICAL_SCOPING_CONFLICT_WITH_LOCAL;
  529.     print_message[INHERITANCE_AND_LEXICAL_SCOPING_CONFLICT_WITH_MEMBER] = PrintINHERITANCE_AND_LEXICAL_SCOPING_CONFLICT_WITH_MEMBER;
  530.     print_message[ILLEGAL_THIS_FIELD_ACCESS] = PrintILLEGAL_THIS_FIELD_ACCESS;
  531.     print_message[CONSTRUCTOR_FOUND_IN_ANONYMOUS_CLASS] = PrintCONSTRUCTOR_FOUND_IN_ANONYMOUS_CLASS;
  532.     print_message[ENCLOSING_INSTANCE_NOT_ACCESSIBLE] = PrintENCLOSING_INSTANCE_NOT_ACCESSIBLE;
  533.     print_message[INVALID_ENCLOSING_INSTANCE] = PrintINVALID_ENCLOSING_INSTANCE;
  534.     print_message[PRIVATE_ENCLOSED_CONSTRUCTOR] = PrintPRIVATE_ENCLOSED_CONSTRUCTOR;
  535.     print_message[ZERO_DIVIDE] = PrintZERO_DIVIDE;
  536.     print_message[VOID_TO_STRING] = PrintVOID_TO_STRING;
  537.  
  538. #ifdef TEST
  539.     for (int k = 0; k < _num_kinds; k++)
  540.         assert(print_message[k] != NULL);
  541. #endif
  542. }
  543.  
  544.  
  545. //
  546. // This procedure uses a  quick sort algorithm to sort the ERRORS
  547. // by the left_line_no and left_column_no fields.
  548. //
  549. void SemanticError::SortMessages()
  550. {
  551.      int lower,
  552.          upper,
  553.          lostack[32],
  554.          histack[32];
  555.  
  556.      int top,
  557.          i,
  558.          j;
  559.      ErrorInfo pivot,
  560.                temp;
  561.  
  562.      top = 0;
  563.      lostack[top] = 0;
  564.      histack[top] = error.Length() - 1;
  565.  
  566.      while(top >= 0)
  567.      {
  568.          lower = lostack[top];
  569.          upper = histack[top];
  570.          top--;
  571.  
  572.          while(upper > lower)
  573.          {
  574.              //
  575.              // The array is most-likely almost sorted. Therefore,
  576.              // we use the middle element as the pivot element.
  577.              //
  578.              i = (lower + upper) / 2;
  579.              pivot = error[i];
  580.              error[i] = error[lower];
  581.  
  582.              //
  583.              // Split the array section indicated by LOWER and UPPER
  584.              // using ARRAY(LOWER) as the pivot.
  585.              //
  586.              i = lower;
  587.              for (j = lower + 1; j <= upper; j++)
  588.                  if ((error[j].left_token < pivot.left_token) ||
  589.                  //
  590.                  // When two error messages start in the same location
  591.                  // and one is nested inside the other, the outer one
  592.                  // is placed first so that it can be printed last.
  593.                  // Recall that its right-span location is reached
  594.                  // after the inner one has been completely processed.
  595.                  //
  596.                      (error[j].left_token == pivot.left_token &&
  597.                       error[j].right_token > pivot.right_token) ||
  598.                  //
  599.                  // When two error messages are at the same location
  600.                  // span, check the NUM field to keep the sort stable.
  601.                  // When the location spans only a single symbol,
  602.                  // the one with the lowest "num" is placed first.
  603.                  //
  604.                      (error[j].left_token  == pivot.left_token  &&
  605.                       error[j].right_token == pivot.right_token &&
  606.                       pivot.left_token == pivot.right_token     &&
  607.                       error[j].num < pivot.num)                       ||
  608.                  //
  609.                  // When two error messages are at the same location
  610.                  // which spans more than one symbol in the source,
  611.                  // the first message is treated as being nested into
  612.                  // the second message and (just like the nested case
  613.                  // above) it is placed last in the sorted sequence.
  614.                  //
  615.                      (error[j].left_token  == pivot.left_token  &&
  616.                       error[j].right_token == pivot.right_token &&
  617.                       pivot.left_token < pivot.right_token      &&
  618.                       error[j].num > pivot.num))
  619.                  {
  620.                      temp = error[++i];
  621.                      error[i] = error[j];
  622.                      error[j] = temp;
  623.                  }
  624.              error[lower] = error[i];
  625.              error[i] = pivot;
  626.  
  627.              top++;
  628.              if ((i - lower) < (upper - i))
  629.              {
  630.                  lostack[top] = i + 1;
  631.                  histack[top] = upper;
  632.                  upper = i - 1;
  633.              }
  634.              else
  635.              {
  636.                  histack[top] = i - 1;
  637.                  lostack[top] = lower;
  638.                  lower = i + 1;
  639.              }
  640.          }
  641.      }
  642.  
  643.      return;
  644. }
  645.  
  646.  
  647. //
  648. // This is the local private procedure that prints the semantic error messages.
  649. //
  650. int SemanticError::PrintMessages()
  651. {
  652.     int return_code = (num_errors > 0 ? 1 : 0);
  653.  
  654.     //
  655.     // If the errors have not yet been dumped,...
  656.     //
  657.     if (! control.option.dump_errors)
  658.     {
  659.         if (control.option.errors)
  660.         {
  661.             if (num_errors == 0)
  662.             {
  663.                 if (control.option.nowarn) // we only had warnings and they should not be reported
  664.                     return return_code;
  665.  
  666.                 cout << "\nIssued "
  667.                      << num_warnings 
  668.                      << (lex_stream -> file_symbol -> semantic == control.system_semantic ? " system" : " semantic")
  669.                      << " warning" << (num_warnings <= 1 ? "" : "s");
  670.             }
  671.             else // we had some errors, and possibly warnings as well
  672.             {
  673.                 cout << "\nFound "
  674.                      << num_errors
  675.                      << (lex_stream -> file_symbol -> semantic == control.system_semantic ? " system" : " semantic")
  676.                      << " error" << (num_errors <= 1 ? "" : "s");
  677.                 if (num_warnings > 0 && !control.option.nowarn) 
  678.                 {
  679.                      cout << " and issued "
  680.                           << num_warnings << " warning" << (num_warnings <= 1 ? "" : "s");
  681.                 }
  682.             }
  683.  
  684.             if (lex_stream -> file_symbol -> semantic != control.system_semantic)
  685.             {
  686.                 cout << " compiling \"";
  687.                 Unicode::Cout(lex_stream -> FileName());
  688.                 cout << '\"';
  689.             }
  690.             cout << ':';
  691.  
  692.             //
  693.             //
  694.             //
  695.             if (lex_stream -> file_symbol -> semantic != control.system_semantic)
  696.             {
  697.                 lex_stream -> RereadInput();
  698.  
  699.                 if (! lex_stream -> InputBuffer())
  700.                 {
  701.                     char *file_name = lex_stream -> FileName();
  702.                     int length = lex_stream -> FileNameLength();
  703.                     wchar_t *name = new wchar_t[length + 1];
  704.                     for (int i = 0; i < length; i++)
  705.                         name[i] = file_name[i];
  706.                     name[length] = U_NULL;
  707.                     control.system_semantic -> ReportSemError(SemanticError::CANNOT_REOPEN_FILE,
  708.                                                               0,
  709.                                                               0,
  710.                                                               name);
  711.                     delete [] name;
  712.                 }
  713.             }
  714.  
  715.             if (lex_stream -> file_symbol -> semantic == control.system_semantic || lex_stream -> InputBuffer())
  716.             {
  717.                 SortMessages();
  718.                 for (int k = 0; k < error.Length(); k++)
  719.                 {
  720.                     if ((warning[error[k].msg_code] != 1) || (! control.option.nowarn))
  721.                     {
  722.                         if (error[k].left_token < error[k].right_token)
  723.                              PrintLargeSource(k);
  724.                         else PrintSmallSource(k);
  725.                         cout << "\n*** " << (warning[error[k].msg_code] == 1
  726.                                                     ? "Warning: "
  727.                                                     : (warning[error[k].msg_code] == 2 && (! control.option.zero_defect)
  728.                                                               ? "Caution: "
  729.                                                               : "Error: "));
  730.                         (print_message[error[k].msg_code]) (error[k], lex_stream, control);
  731.                         cout << '\n';
  732.                     }
  733.                 }
  734.                 lex_stream -> DestroyInput();
  735.             }
  736.         }
  737.         else
  738.         {
  739.             if (lex_stream -> file_symbol -> semantic != control.system_semantic)
  740.             {
  741.                 if (! lex_stream -> ComputeColumns())
  742.                 {
  743.                     char *file_name = lex_stream -> FileName();
  744.                     int length = lex_stream -> FileNameLength();
  745.                     wchar_t *name = new wchar_t[length + 1];
  746.                     for (int i = 0; i < length; i++)
  747.                         name[i] = file_name[i];
  748.                     name[length] = U_NULL;
  749.                     control.system_semantic -> ReportSemError(SemanticError::CANNOT_COMPUTE_COLUMNS,
  750.                                                               0,
  751.                                                               0,
  752.                                                               name);
  753.                     delete [] name;
  754.                 }
  755.             }
  756.  
  757.             SortMessages();
  758.             for (int k = 0; k < error.Length(); k++)
  759.             {
  760.                 if ((warning[error[k].msg_code] != 1) || (! control.option.nowarn))
  761.                     PrintEmacsMessage(k);
  762.             }
  763.         }
  764.     }
  765.  
  766.     cout.flush();
  767.     cerr.flush();
  768.  
  769.     return return_code;
  770. }
  771.  
  772.  
  773. void SemanticError::PrintEmacsMessage(int k)
  774. {
  775.     int left_line_no    = lex_stream -> Line(error[k].left_token),
  776.         left_column_no  = lex_stream -> Column(error[k].left_token),
  777.         right_line_no   = lex_stream -> Line(error[k].right_token),
  778.         right_column_no = lex_stream -> Column(error[k].right_token);
  779.  
  780.     if (right_column_no != 0) // could not compute a column number
  781.         right_column_no += (error[k].right_string_length - 1); // point to last character in right token
  782.  
  783.     Unicode::Cout(lex_stream -> FileName());
  784.     cout << ':' << left_line_no  << ':' << left_column_no 
  785.          << ':' << right_line_no << ':' << right_column_no
  786.          << (warning[error[k].msg_code] == 1
  787.                     ? ":\n    Warning: "
  788.                     : (warning[error[k].msg_code] == 2  && (! control.option.zero_defect)
  789.                               ? ":\n    Caution: "
  790.                               : ":\n    Error: "));
  791.     (print_message[error[k].msg_code]) (error[k], lex_stream, control);
  792.     cout << '\n';
  793.  
  794.     return;
  795. }
  796.  
  797.  
  798. //
  799. // This procedure is invoked to print a large message that may
  800. // span more than one line. The parameter message points to the
  801. // starting line. The parameter k points to the error message in
  802. // the error structure.
  803. //
  804. void SemanticError::PrintLargeSource(int k)
  805. {
  806.     int left_line_no    = lex_stream -> Line(error[k].left_token),
  807.         left_column_no  = lex_stream -> Column(error[k].left_token),
  808.         right_line_no   = lex_stream -> Line(error[k].right_token),
  809.         right_column_no = lex_stream -> Column(error[k].right_token);
  810.  
  811.     if (left_line_no == right_line_no)
  812.     {
  813.         if (left_line_no == 0)
  814.             cout << "\n";
  815.         else
  816.         {
  817.             cout << "\n\n";
  818.             cout.width(6);
  819.             cout << left_line_no << ". ";
  820.             for (int i = lex_stream -> LineStart(left_line_no); i <= lex_stream -> LineEnd(left_line_no); i++)
  821.                 Unicode::Cout(lex_stream -> InputBuffer()[i]);
  822.  
  823.             cout.width(left_column_no + 8);
  824.             cout << "<";
  825.             cout.width(right_column_no + error[k].right_string_length - left_column_no - 1);
  826.             cout.fill('-');
  827.             cout << ">";
  828.             cout.fill(' ');
  829.         }
  830.     }
  831.     else
  832.     {
  833.         cout << "\n\n";
  834.         cout.width(left_column_no + 8);
  835.         cout << "<";
  836.  
  837.         cout.width(lex_stream -> LineSegmentLength(error[k].left_token));
  838.         cout.fill('-');
  839.         cout << "\n";
  840.         cout.fill(' ');
  841.  
  842.         cout.width(6);
  843.         cout << left_line_no << ". ";
  844.         for (int i = lex_stream -> LineStart(left_line_no); i <= lex_stream -> LineEnd(left_line_no); i++)
  845.             Unicode::Cout(lex_stream -> InputBuffer()[i]);
  846.  
  847.         if (right_line_no > left_line_no + 1)
  848.         {
  849.             cout.width(left_column_no + 7);
  850.             cout << " ";
  851.             cout << ". . .\n";
  852.         }
  853.  
  854.         cout.width(6);
  855.         cout << right_line_no << ". ";
  856.         for (int j = lex_stream -> LineStart(right_line_no); j <= lex_stream -> LineEnd(right_line_no); j++)
  857.             Unicode::Cout(lex_stream -> InputBuffer()[j]);
  858.  
  859.         cout.width(8);
  860.         cout << "";
  861.         cout.width(right_column_no + error[k].right_string_length - 1);
  862.         cout.fill('-');
  863.         cout << ">";
  864.         cout.fill(' ');
  865.     }
  866.  
  867.     return;
  868. }
  869.  
  870. //
  871. // This procedure is invoked to print a small message that may
  872. // only span a single line. The parameter k points to the error
  873. // message in the error structure.
  874. //
  875. void SemanticError::PrintSmallSource(int k)
  876. {
  877.     int left_line_no = lex_stream -> Line(error[k].left_token);
  878.  
  879.     if (left_line_no == 0)
  880.         cout << "\n";
  881.     else
  882.     {
  883.         cout << "\n\n";
  884.         cout.width(6);
  885.         cout << left_line_no;
  886.         cout << ". ";
  887.  
  888.         for (int i = lex_stream -> LineStart(left_line_no); i <= lex_stream -> LineEnd(left_line_no); i++)
  889.             Unicode::Cout(lex_stream -> InputBuffer()[i]);
  890.  
  891.         int left_column_no = lex_stream -> Column(error[k].left_token),
  892.             right_column_no = lex_stream -> Column(error[k].right_token);
  893.  
  894.         cout.width(left_column_no + 7);
  895.         cout << "";
  896.         if (left_column_no == right_column_no && error[k].right_string_length == 1)
  897.             cout << '^';
  898.         else
  899.         {
  900.             cout << '<';
  901.             cout.width(right_column_no + error[k].right_string_length - left_column_no - 1);
  902.             cout.fill('-');
  903.             cout << ">";
  904.             cout.fill(' ');
  905.         }
  906.     }
  907.  
  908.     return;
  909. }
  910.  
  911.  
  912. //
  913. // These "print_" procedures are invoked to print specific
  914. // error messages. The parameter err identifies the error to
  915. // be processed.
  916. //
  917. void SemanticError::PrintBAD_ERROR(ErrorInfo &err, LexStream *lex_stream, Control &control)
  918. {
  919.     cerr << "chaos: Error code " << err.msg_code << " is not a valid error message code\n";
  920.  
  921.     return;
  922. }
  923.  
  924.  
  925. void SemanticError::PrintDEFAULT_ERROR(ErrorInfo &err, LexStream *lex_stream, Control &control)
  926. {
  927.     if (err.insert1)
  928.         Unicode::Cout(err.insert1);
  929.     if (err.insert2)
  930.         Unicode::Cout(err.insert2);
  931.     if (err.insert3)
  932.         Unicode::Cout(err.insert3);
  933.     if (err.insert4)
  934.         Unicode::Cout(err.insert4);
  935.     if (err.insert5)
  936.         Unicode::Cout(err.insert5);
  937.     if (err.insert6)
  938.         Unicode::Cout(err.insert6);
  939.     if (err.insert7)
  940.         Unicode::Cout(err.insert7);
  941.     if (err.insert8)
  942.         Unicode::Cout(err.insert8);
  943.     if (err.insert9)
  944.         Unicode::Cout(err.insert9);
  945.  
  946.     return;
  947. }
  948.  
  949.  
  950. void SemanticError::PrintINVALID_OPTION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  951. {
  952.     cout << '\"';
  953.     Unicode::Cout(err.insert1);
  954.     cout << "\" is an invalid option; "
  955.          << StringConstant::U8S_command_format;
  956.  
  957.     return;
  958. }
  959.  
  960.  
  961. void SemanticError::PrintINVALID_K_OPTION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  962. {
  963.     cout << "No argument specified for +K option. The proper form is \"+Kxxx=xxx\" (with no intervening space)";
  964.  
  965.     return;
  966. }
  967.  
  968.  
  969. void SemanticError::PrintINVALID_K_TARGET(ErrorInfo &err, LexStream *lex_stream, Control &control)
  970. {
  971.     cout << '\"';
  972.     Unicode::Cout(err.insert1);
  973.     cout << "\" is not a valid target in a +K option. The target must be a numeric type or boolean";
  974.  
  975.     return;
  976. }
  977.  
  978.  
  979. void SemanticError::PrintINVALID_TAB_VALUE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  980. {
  981.     cout << '\"';
  982.     Unicode::Cout(err.insert1);
  983.     cout << "\" is not a valid tab size. An integer value is expected";
  984.  
  985.     return;
  986. }
  987.  
  988.  
  989. void SemanticError::PrintINVALID_DIRECTORY(ErrorInfo &err, LexStream *lex_stream, Control &control)
  990. {
  991.     cout << "The directory specified in the \"-d\" option, \"";
  992.     Unicode::Cout(err.insert1);
  993.     cout << "\", is either invalid or it could not be expanded";
  994.  
  995.     return;
  996. }
  997.  
  998.  
  999. void SemanticError::PrintUNSUPPORTED_OPTION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1000. {
  1001.     cout << "This option \"";
  1002.     Unicode::Cout(err.insert1);
  1003.     cout << "\" is currently unsupported";
  1004.  
  1005.     return;
  1006. }
  1007.  
  1008.  
  1009. void SemanticError::PrintNO_CURRENT_DIRECTORY(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1010. {
  1011.     cout << "Could not open current directory";
  1012.     return;
  1013. }
  1014.  
  1015.  
  1016. void SemanticError::PrintCANNOT_OPEN_ZIP_FILE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1017. {
  1018.     cout << "\"";
  1019.     Unicode::Cout(err.insert1);
  1020.     cout << "\" is either not a valid zip file or it contains a zip file comment. "
  1021.             "If it contains a comment, rezip it without the comment...";
  1022.  
  1023.     return;
  1024. }
  1025.  
  1026.  
  1027. void SemanticError::PrintPACKAGE_NOT_FOUND(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1028. {
  1029.     cout << "Could not find package named: \n";
  1030.     for (int i = 1; i < control.classpath.Length(); i++)
  1031.     {
  1032.         PathSymbol *path_symbol = control.classpath[i];
  1033.         wchar_t *path = path_symbol -> Name();
  1034.  
  1035.         cout << "                ";
  1036.         Unicode::Cout(path);
  1037.         if (path_symbol -> IsZip())
  1038.         {
  1039.             cout << "(";
  1040.             Unicode::Cout(err.insert1);
  1041.             cout << ")";
  1042.         }
  1043.         else
  1044.         {
  1045.             cout << "/";
  1046.             Unicode::Cout(err.insert1);
  1047.         }
  1048.  
  1049.         if (i + 2 < control.classpath.Length())
  1050.              cout << ", \n";
  1051.         else if (i + 2 == control.classpath.Length())
  1052.              cout << " or \n";
  1053.     }
  1054.  
  1055.     return;
  1056. }
  1057.  
  1058.  
  1059. void SemanticError::PrintCANNOT_OPEN_DIRECTORY(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1060. {
  1061.     cout << "Unable to open directory \"";
  1062.     Unicode::Cout(err.insert1);
  1063.     cout << "\"";
  1064.  
  1065.     return;
  1066. }
  1067.  
  1068.  
  1069. void SemanticError::PrintBAD_INPUT_FILE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1070. {
  1071.     cout << "The input file \"";
  1072.     Unicode::Cout(err.insert1);
  1073.     cout << "\" does not have the \".java\" extension";
  1074.  
  1075.     return;
  1076. }
  1077.  
  1078.  
  1079. void SemanticError::PrintUNREADABLE_INPUT_FILE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1080. {
  1081.     cout << "The input file \"";
  1082.     Unicode::Cout(err.insert1);
  1083.     cout << "\" was not found";
  1084.  
  1085.     return;
  1086. }
  1087.  
  1088.  
  1089. void SemanticError::PrintCANNOT_REOPEN_FILE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1090. {
  1091.     cout << "Unable to reopen file \"";
  1092.     Unicode::Cout(err.insert1);
  1093.     cout << "\"";
  1094.  
  1095.     return;
  1096. }
  1097.  
  1098.  
  1099. void SemanticError::PrintCANNOT_WRITE_FILE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1100. {
  1101.     cout << "Unable to write file \"";
  1102.     Unicode::Cout(err.insert1);
  1103.     cout << "\"";
  1104.  
  1105.     return;
  1106. }
  1107.  
  1108.  
  1109. void SemanticError::PrintCANNOT_COMPUTE_COLUMNS(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1110. {
  1111.     cout << "Unable to reopen file \"";
  1112.     Unicode::Cout(err.insert1);
  1113.     cout << "\". Therefore, column positions may be incorrect";
  1114.  
  1115.     return;
  1116. }
  1117.  
  1118.  
  1119. void SemanticError::PrintREDUNDANT_ABSTRACT(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1120. {
  1121.     cout << "The use of the \"abstract\" modifier in this context is redundant and strongly discouraged as a matter of style";
  1122.  
  1123.     return;
  1124. }
  1125.  
  1126.  
  1127. void SemanticError::PrintREDUNDANT_FINAL(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1128. {
  1129.     cout << "The use of the \"final\" modifier in this context is redundant and strongly discouraged as a matter of style";
  1130.  
  1131.     return;
  1132. }
  1133.  
  1134.  
  1135. void SemanticError::PrintREDUNDANT_PUBLIC(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1136. {
  1137.     cout << "The use of the \"public\" modifier in this context is redundant and strongly discouraged as a matter of style";
  1138.  
  1139.     return;
  1140. }
  1141.  
  1142.  
  1143. void SemanticError::PrintREDUNDANT_STATIC(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1144. {
  1145.     cout << "The use of the \"static\" modifier in this context is redundant and strongly discouraged as a matter of style";
  1146.  
  1147.     return;
  1148. }
  1149.  
  1150.  
  1151. void SemanticError::PrintEMPTY_DECLARATION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1152. {
  1153.     cout << "An EmptyDeclaration is a deprecated feature that should not be used - \";\" ignored";
  1154.  
  1155.     return;
  1156. }
  1157.  
  1158.  
  1159. void SemanticError::PrintOBSOLESCENT_ABSTRACT(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1160. {
  1161.     cout << "Every interface in implicitly abstract. This modifier is obsolete and should not be used in new Java programs";
  1162.  
  1163.     return;
  1164. }
  1165.  
  1166.  
  1167. void SemanticError::PrintOBSOLESCENT_BRACKETS(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1168. {
  1169.     cout << "The use of empty bracket pairs following a MethodDeclarator should not be used in new Java programs";
  1170.  
  1171.     return;
  1172. }
  1173.  
  1174.  
  1175. void SemanticError::PrintNO_TYPES(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1176. {
  1177.     cout << "This compilation unit contains no type declaration";
  1178.  
  1179.     return;
  1180. }
  1181.  
  1182.  
  1183. void SemanticError::PrintTYPE_IN_MULTIPLE_FILES(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1184. {
  1185.     cout << "The file \"";
  1186.     if (NotDot(err.insert1))
  1187.     {
  1188.         Unicode::Cout(err.insert1);
  1189.         cout << "/";
  1190.     }
  1191.     Unicode::Cout(err.insert2);
  1192.     cout << ".java\" contains type \"";
  1193.     Unicode::Cout(err.insert4);
  1194.     cout << "\" which conflicts with file \"";
  1195.     if (NotDot(err.insert3))
  1196.     {
  1197.         Unicode::Cout(err.insert3);
  1198.         cout << "/";
  1199.     }
  1200.     Unicode::Cout(err.insert4);
  1201.     cout << ".java\"";
  1202.  
  1203.     return;
  1204. }
  1205.  
  1206.  
  1207. void SemanticError::PrintPACKAGE_TYPE_CONFLICT(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1208. {
  1209.     cout << "The type \"";
  1210.     if (NotDot(err.insert1))
  1211.     {
  1212.         Unicode::Cout(err.insert1);
  1213.         cout << "/";
  1214.     }
  1215.     Unicode::Cout(err.insert2);
  1216.     cout << "\" contained in file \"";
  1217.     Unicode::Cout(err.insert3);
  1218.     cout << "\" conflicts with the package \"";
  1219.     if (NotDot(err.insert1))
  1220.     {
  1221.         Unicode::Cout(err.insert1);
  1222.         cout << "/";
  1223.     }
  1224.     Unicode::Cout(err.insert2);
  1225.     cout << "\"";
  1226.  
  1227.     return;
  1228. }
  1229.  
  1230.  
  1231. void SemanticError::PrintDIRECTORY_FILE_CONFLICT(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1232. {
  1233.     cout << "The type \"";
  1234.     Unicode::Cout(err.insert1);
  1235.     cout << "\" contained in file \"";
  1236.     if (NotDot(err.insert2))
  1237.     {
  1238.         Unicode::Cout(err.insert2);
  1239.         cout << "/";
  1240.     }
  1241.     Unicode::Cout(err.insert3);
  1242.     cout << ".java\" conflicts with the directory \"";
  1243.     Unicode::Cout(err.insert4);
  1244.     cout << "\"";
  1245.  
  1246.     return;
  1247. }
  1248.  
  1249.  
  1250. void SemanticError::PrintFILE_FILE_CONFLICT(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1251. {
  1252.     cout << "Cannot write class file \"";
  1253.     Unicode::Cout(err.insert1);
  1254.     cout << ".class\" because that name conflicts with the name of the class file \"";
  1255.     Unicode::Cout(err.insert2);
  1256.     cout << "\" in directory \"";
  1257.     Unicode::Cout(err.insert3);
  1258.     cout << "\". This is illegal because file names are case-insensitive in this system";
  1259.  
  1260.     return;
  1261. }
  1262.  
  1263.  
  1264. void SemanticError::PrintMULTIPLE_PUBLIC_TYPES(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1265. {
  1266.     cout << "The type \"";
  1267.     Unicode::Cout(err.insert1);
  1268.     cout << "\" is declared public in compilation unit \"";
  1269.     Unicode::Cout(lex_stream -> FileName());
  1270.     cout<< "\" which also contains the public type, \"";
  1271.     Unicode::Cout(err.insert2);
  1272.     cout << "\"";
  1273.  
  1274.     return;
  1275. }
  1276.  
  1277.  
  1278. void SemanticError::PrintMISMATCHED_TYPE_AND_FILE_NAMES(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1279. {
  1280.     cout << "The public type \"";
  1281.     Unicode::Cout(err.insert1);
  1282.     cout << "\" does not match the name of its containing file \"";
  1283.     Unicode::Cout(lex_stream -> FileName());
  1284.     cout << "\"";
  1285.  
  1286.     return;
  1287. }
  1288.  
  1289.  
  1290. void SemanticError::PrintREFERENCE_TO_TYPE_IN_MISMATCHED_FILE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1291. {
  1292.     cout << "The type \"";
  1293.     Unicode::Cout(err.insert1);
  1294.     cout << "\" is defined in the file \"";
  1295.     Unicode::Cout(err.insert2);
  1296.     cout << ".java\" but referenced in the file \"";
  1297.     Unicode::Cout(lex_stream -> FileName());
  1298.     cout << "\". It is recommended that it be redefined in \"";
  1299.     Unicode::Cout(err.insert1);
  1300.     cout << ".java\"";
  1301.  
  1302.     return;
  1303. }
  1304.  
  1305.  
  1306. void SemanticError::PrintDUPLICATE_INNER_TYPE_NAME(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1307. {
  1308.     cout << "The inner type named \"";
  1309.     Unicode::Cout(err.insert1);
  1310.     cout << "\" is nested in an outer class of the same name at location ";
  1311.     Unicode::Cout(err.insert2);
  1312.  
  1313.     return;
  1314. }
  1315.  
  1316.  
  1317. void SemanticError::PrintDUPLICATE_TYPE_DECLARATION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1318. {
  1319.     cout << "Duplicate declaration of type \"";
  1320.     Unicode::Cout(err.insert1);
  1321.     cout << "\". The other occurrence is at location ";
  1322.     Unicode::Cout(err.insert2);
  1323.  
  1324.     return;
  1325. }
  1326.  
  1327.  
  1328. void SemanticError::PrintUNINITIALIZED_FIELD(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1329. {
  1330.     cout << "The field \"";
  1331.     Unicode::Cout(err.insert1);
  1332.     cout << "\" is not initialized";
  1333.  
  1334.     return;
  1335. }
  1336.  
  1337.  
  1338. void SemanticError::PrintDUPLICATE_MODIFIER(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1339. {
  1340.     cout << "Duplicate specification of this modifier";
  1341.  
  1342.     return;
  1343. }
  1344.  
  1345.  
  1346. void SemanticError::PrintDUPLICATE_ACCESS_MODIFIER(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1347. {
  1348.     cout << "Duplicate specification of an access modifier. "
  1349.             "Only one instance of \"public\", \"private\", or \"protected\" may appear in a declaration";
  1350.  
  1351.     return;
  1352. }
  1353.  
  1354.  
  1355. void SemanticError::PrintINVALID_TOP_LEVEL_CLASS_MODIFIER(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1356. {
  1357.     Unicode::Cout(err.insert1);
  1358.     cout << " is not a valid modifier for a top-level class";
  1359.  
  1360.     return;
  1361. }
  1362.  
  1363.  
  1364. void SemanticError::PrintINVALID_INNER_CLASS_MODIFIER(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1365. {
  1366.     Unicode::Cout(err.insert1);
  1367.     cout << " is not a valid modifier for an inner class";
  1368.  
  1369.     return;
  1370. }
  1371.  
  1372.  
  1373. void SemanticError::PrintINVALID_STATIC_INNER_CLASS_MODIFIER(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1374. {
  1375.     Unicode::Cout(err.insert1);
  1376.     cout << " is not a valid modifier for an inner class that is enclosed in an interface";
  1377.  
  1378.     return;
  1379. }
  1380.  
  1381.  
  1382. void SemanticError::PrintINVALID_LOCAL_CLASS_MODIFIER(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1383. {
  1384.     Unicode::Cout(err.insert1);
  1385.     cout << " is not a valid modifier for a local inner class";
  1386.  
  1387.     return;
  1388. }
  1389.  
  1390.  
  1391. void SemanticError::PrintFINAL_ABSTRACT_CLASS(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1392. {
  1393.     cout << "A class may not be declared both \"final\" and \"abstract\"";
  1394.  
  1395.     return;
  1396. }
  1397.  
  1398.  
  1399. void SemanticError::PrintINVALID_INTERFACE_MODIFIER(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1400. {
  1401.     Unicode::Cout(err.insert1);
  1402.     cout << " is not a valid interface modifier";
  1403.  
  1404.     return;
  1405. }
  1406.  
  1407.  
  1408. void SemanticError::PrintVOLATILE_FINAL(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1409. {
  1410.     cout << "A \"volatile\" field may not be declared \"final\"";
  1411.  
  1412.     return;
  1413. }
  1414.  
  1415.  
  1416. void SemanticError::PrintFINAL_VOLATILE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1417. {
  1418.     cout << "A \"final\" field may not be declared \"volatile\"";
  1419.  
  1420.     return;
  1421. }
  1422.  
  1423.  
  1424. void SemanticError::PrintINVALID_FIELD_MODIFIER(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1425. {
  1426.     Unicode::Cout(err.insert1);
  1427.     cout << " is not a valid field modifier";
  1428.  
  1429.     return;
  1430. }
  1431.  
  1432.  
  1433. void SemanticError::PrintINVALID_LOCAL_MODIFIER(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1434. {
  1435.     Unicode::Cout(err.insert1);
  1436.     cout << " is not a valid local variable or parameter modifier";
  1437.  
  1438.     return;
  1439. }
  1440.  
  1441.  
  1442. void SemanticError::PrintINVALID_METHOD_MODIFIER(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1443. {
  1444.     Unicode::Cout(err.insert1);
  1445.     cout << " is not a valid method modifier";
  1446.  
  1447.     return;
  1448. }
  1449.  
  1450.  
  1451. void SemanticError::PrintINVALID_SIGNATURE_MODIFIER(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1452. {
  1453.     Unicode::Cout(err.insert1);
  1454.     cout << " is not a valid signature modifier";
  1455.  
  1456.     return;
  1457. }
  1458.  
  1459.  
  1460. void SemanticError::PrintINVALID_CONSTRUCTOR_MODIFIER(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1461. {
  1462.     Unicode::Cout(err.insert1);
  1463.     cout << " is not a valid constructor modifier";
  1464.  
  1465.     return;
  1466. }
  1467.  
  1468.  
  1469. void SemanticError::PrintINVALID_CONSTANT_MODIFIER(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1470. {
  1471.     Unicode::Cout(err.insert1);
  1472.     cout << " is not a valid constant modifier";
  1473.  
  1474.     return;
  1475. }
  1476.  
  1477.  
  1478. void SemanticError::PrintPARENT_TYPE_IN_UNNAMED_PACKAGE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1479. {
  1480.     cout << "The type associated with this construct is (or depends on) the type ";
  1481.     if (NotDot(err.insert1))
  1482.     {
  1483.         Unicode::Cout(err.insert1);
  1484.         cout << "/";
  1485.     }
  1486.     Unicode::Cout(err.insert2);
  1487.     cout << " which is contained in an unnamed package";
  1488.  
  1489.     return;
  1490. }
  1491.  
  1492.  
  1493. void SemanticError::PrintRECOMPILATION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1494. {
  1495.     cout << "The type associated with this construct depends on file ";
  1496.     if (NotDot(err.insert1))
  1497.     {
  1498.         Unicode::Cout(err.insert1);
  1499.         cout << "/";
  1500.     }
  1501.     Unicode::Cout(err.insert2);
  1502.     cout << ".class which, in turn, depends on file ";
  1503.     if (NotDot(err.insert3))
  1504.     {
  1505.         Unicode::Cout(err.insert3);
  1506.         cout << "/";
  1507.     }
  1508.     Unicode::Cout(err.insert4);
  1509.     cout << ".java. All files that depend on this source file, in particular, ";
  1510.     if (NotDot(err.insert1))
  1511.     {
  1512.         Unicode::Cout(err.insert1);
  1513.         cout << "/";
  1514.     }
  1515.     Unicode::Cout(err.insert2);
  1516.     cout << ".java should be recompiled";
  1517.  
  1518.     return;
  1519. }
  1520.  
  1521.  
  1522. void SemanticError::PrintTYPE_NOT_FOUND(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1523. {
  1524.     cout << "Type ";
  1525.     if (NotDot(err.insert1))
  1526.     {
  1527.         Unicode::Cout(err.insert1);
  1528.         cout << "/";
  1529.     }
  1530.     Unicode::Cout(err.insert2);
  1531.     cout << " was not found";
  1532.  
  1533.     return;
  1534. }
  1535.  
  1536.  
  1537. void SemanticError::PrintDUPLICATE_ON_DEMAND_IMPORT(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1538. {
  1539.     cout << "Type ";
  1540.     Unicode::Cout(err.insert1);
  1541.     cout << " is imported on demand from package ";
  1542.     Unicode::Cout(err.insert2);
  1543.     cout << " and package ";
  1544.     Unicode::Cout(err.insert3);
  1545.  
  1546.     return;
  1547. }
  1548.  
  1549.  
  1550. void SemanticError::PrintNOT_A_TYPE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1551. {
  1552.     cout << "A type is expected here";
  1553.  
  1554.     return;
  1555. }
  1556.  
  1557.  
  1558. void SemanticError::PrintNOT_A_CLASS(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1559. {
  1560.     cout << "Interface \"";
  1561.     if (NotDot(err.insert1))
  1562.     {
  1563.         Unicode::Cout(err.insert1);
  1564.         cout << '/';
  1565.     }
  1566.     Unicode::Cout(err.insert2);
  1567.     cout << "\" cannot be used where a class is expected";
  1568.  
  1569.     return;
  1570. }
  1571.  
  1572.  
  1573. void SemanticError::PrintNOT_AN_INTERFACE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1574. {
  1575.     cout << "Class ";
  1576.     if (NotDot(err.insert1))
  1577.     {
  1578.         Unicode::Cout(err.insert1);
  1579.         cout << '/';
  1580.     }
  1581.     Unicode::Cout(err.insert2);
  1582.     cout << " cannot be used where an interface is expected";
  1583.  
  1584.     return;
  1585. }
  1586.  
  1587.  
  1588. void SemanticError::PrintSUPER_IS_FINAL(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1589. {
  1590.     cout << "The super class \"";
  1591.     if (NotDot(err.insert1))
  1592.     {
  1593.         Unicode::Cout(err.insert1);
  1594.         cout << '/';
  1595.     }
  1596.     Unicode::Cout(err.insert2);
  1597.     cout << "\" is final. A final class must not have subclasses";
  1598.  
  1599.     return;
  1600. }
  1601.  
  1602.  
  1603. void SemanticError::PrintOBJECT_WITH_SUPER_TYPE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1604. {
  1605.     cout << "The type ";
  1606.     Unicode::Cout(err.insert1);
  1607.     cout << '/';
  1608.     Unicode::Cout(err.insert2);
  1609.     cout << " must not have a super type";
  1610.  
  1611.     return;
  1612. }
  1613.  
  1614.  
  1615. void SemanticError::PrintOBJECT_HAS_NO_SUPER_TYPE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1616. {
  1617.     cout << "The type ";
  1618.     Unicode::Cout(err.insert1);
  1619.     cout << '/';
  1620.     Unicode::Cout(err.insert2);
  1621.     cout << " does not have a super type";
  1622.  
  1623.     return;
  1624. }
  1625.  
  1626.  
  1627. void SemanticError::PrintDUPLICATE_FIELD(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1628. {
  1629.     cout << "Duplicate declaration of field \"";
  1630.     Unicode::Cout(err.insert1);
  1631.     cout << "\" in type \"";
  1632.     Unicode::Cout(err.insert2);
  1633.     cout << "\"";
  1634.  
  1635.     return;
  1636. }
  1637.  
  1638.  
  1639. void SemanticError::PrintDUPLICATE_METHOD(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1640. {
  1641.     cout << "Duplicate declaration of method \"";
  1642.     Unicode::Cout(err.insert1);
  1643.     cout << "\" in type \"";
  1644.     Unicode::Cout(err.insert2);
  1645.     cout << "\"";
  1646.  
  1647.     return;
  1648. }
  1649.  
  1650.  
  1651. void SemanticError::PrintMISMATCHED_INHERITED_METHOD(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1652. {
  1653.     cout << "The return type of method \"";
  1654.     Unicode::Cout(err.insert1);
  1655.     cout << "\" does not match the return type of method \"";
  1656.     Unicode::Cout(err.insert2);
  1657.     cout << "\" inherited from type \"";
  1658.     if (NotDot(err.insert3))
  1659.     {
  1660.         Unicode::Cout(err.insert3);
  1661.         cout << "/";
  1662.     }
  1663.     Unicode::Cout(err.insert4);
  1664.     cout << "\"";
  1665.  
  1666.     return;
  1667. }
  1668.  
  1669.  
  1670. void SemanticError::PrintMISMATCHED_INHERITED_METHOD_EXTERNALLY(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1671. {
  1672.     cout << "In class \"";
  1673.     Unicode::Cout(err.insert1);
  1674.     cout << "\", the method \"";
  1675.     Unicode::Cout(err.insert2);
  1676.     cout << "\", inherited from type \"";
  1677.     if (NotDot(err.insert3))
  1678.     {
  1679.         Unicode::Cout(err.insert3);
  1680.         cout << "/";
  1681.     }
  1682.     Unicode::Cout(err.insert4);
  1683.     cout << "\", does not have the same return type as the overridden method \"";
  1684.     Unicode::Cout(err.insert5);
  1685.     cout << "\", inherited from type \"";
  1686.     if (NotDot(err.insert6))
  1687.     {
  1688.         Unicode::Cout(err.insert6);
  1689.         cout << "/";
  1690.     }
  1691.     Unicode::Cout(err.insert7);
  1692.     cout << "\"";
  1693.  
  1694.     return;
  1695. }
  1696.  
  1697.  
  1698. void SemanticError::PrintDUPLICATE_CONSTRUCTOR(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1699. {
  1700.     cout << "Duplicate declaration of this constructor in type \"";
  1701.     Unicode::Cout(err.insert1);
  1702.     cout << "\"";
  1703.  
  1704.     return;
  1705. }
  1706.  
  1707.  
  1708. void SemanticError::PrintMISMATCHED_CONSTRUCTOR_NAME(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1709. {
  1710.     cout << "The name of the constructor \"";
  1711.     Unicode::Cout(err.insert1);
  1712.     cout << "\" does not match the name of the class \"";
  1713.     Unicode::Cout(err.insert2);
  1714.     cout << "\"";
  1715.  
  1716.     return;
  1717. }
  1718.  
  1719.  
  1720. void SemanticError::PrintMETHOD_WITH_CONSTRUCTOR_NAME(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1721. {
  1722.     cout << "The name of this method \"";
  1723.     Unicode::Cout(err.insert1);
  1724.     cout << "\" matches the name of the containing class. "
  1725.             "However, the method is not a constructor since it contains a return type";
  1726.  
  1727.     return;
  1728. }
  1729.  
  1730.  
  1731. void SemanticError::PrintDUPLICATE_FORMAL_PARAMETER(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1732. {
  1733.     cout << "Duplicate declaration of formal parameter ";
  1734.     Unicode::Cout(err.insert1);
  1735.  
  1736.     return;
  1737. }
  1738.  
  1739.  
  1740. void SemanticError::PrintDUPLICATE_LOCAL_VARIABLE_DECLARATION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1741. {
  1742.     cout << "Duplicate declaration of local variable \"";
  1743.     Unicode::Cout(err.insert1);
  1744.     cout << "\"";
  1745.  
  1746.     return;
  1747. }
  1748.  
  1749.  
  1750. void SemanticError::PrintDUPLICATE_LOCAL_TYPE_DECLARATION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1751. {
  1752.     cout << "Duplicate declaration of local class \"";
  1753.     Unicode::Cout(err.insert1);
  1754.     cout << "\". The other occurrence is at location ";
  1755.     Unicode::Cout(err.insert2);
  1756.  
  1757.     return;
  1758. }
  1759.  
  1760.  
  1761. void SemanticError::PrintMULTIPLE_DEFAULT_LABEL(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1762. {
  1763.     cout << "Multiple specification of default label in switch statement";
  1764.  
  1765.     return;
  1766. }
  1767.  
  1768.  
  1769. void SemanticError::PrintUNDECLARED_LABEL(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1770. {
  1771.     Unicode::Cout(err.insert1);
  1772.     cout << " is an undeclared label";
  1773.  
  1774.     return;
  1775. }
  1776.  
  1777.  
  1778. void SemanticError::PrintDUPLICATE_LABEL(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1779. {
  1780.     cout << "Duplicate declaration of label \"";
  1781.     Unicode::Cout(err.insert1);
  1782.     cout << "\"";
  1783.  
  1784.     return;
  1785. }
  1786.  
  1787.  
  1788. void SemanticError::PrintTYPE_NOT_THROWABLE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1789. {
  1790.     cout << "The type \"";
  1791.     if (NotDot(err.insert1))
  1792.     {
  1793.         Unicode::Cout(err.insert1);
  1794.         cout << "/";
  1795.     }
  1796.     Unicode::Cout(err.insert2);
  1797.     cout << "\" is not a subclass of \"Throwable\"";
  1798.  
  1799.     return;
  1800. }
  1801.  
  1802.  
  1803. void SemanticError::PrintCATCH_PRIMITIVE_TYPE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1804. {
  1805.     cout << "A primitive type cannot be used to declare a catch clause parameter - the type Error is assumed";
  1806.  
  1807.     return;
  1808. }
  1809.  
  1810.  
  1811. void SemanticError::PrintCATCH_ARRAY_TYPE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1812. {
  1813.     cout << "A array type cannot be used to declare a catch clause parameter - the type Error is assumed";
  1814.  
  1815.     return;
  1816. }
  1817.  
  1818.  
  1819. void SemanticError::PrintAMBIGUOUS_NAME(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1820. {
  1821.     cout << "The name \"";
  1822.     Unicode::Cout(err.insert1);
  1823.     cout << "\" is an ambiguous name found in the types \"";
  1824.     if (NotDot(err.insert2))
  1825.     {
  1826.         Unicode::Cout(err.insert2);
  1827.         cout << "/";
  1828.     }
  1829.     Unicode::Cout(err.insert3);
  1830.     cout << "\" and \"";
  1831.     if (NotDot(err.insert4))
  1832.     {
  1833.         Unicode::Cout(err.insert4);
  1834.         cout << "/";
  1835.     }
  1836.     Unicode::Cout(err.insert5);
  1837.     cout << "\"";
  1838.  
  1839.     return;
  1840. }
  1841.  
  1842.  
  1843. void SemanticError::PrintFIELD_IS_TYPE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1844. {
  1845.     cout << "The name \"";
  1846.     Unicode::Cout(err.insert1);
  1847.     cout << "\" cannot be dereferenced as it represents a type";
  1848.  
  1849.     return;
  1850. }
  1851.  
  1852.  
  1853. void SemanticError::PrintFIELD_NOT_FOUND(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1854. {
  1855.     cout << "No field named \"";
  1856.     Unicode::Cout(err.insert1);
  1857.     cout << "\" was found in type \"";
  1858.     if (NotDot(err.insert2))
  1859.     {
  1860.         Unicode::Cout(err.insert2);
  1861.         cout << "/";
  1862.     }
  1863.     Unicode::Cout(err.insert3);
  1864.     cout << "\"";
  1865.  
  1866.     return;
  1867. }
  1868.  
  1869.  
  1870. void SemanticError::PrintFIELD_NAME_MISSPELLED(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1871. {
  1872.     cout << "No field named \"";
  1873.     Unicode::Cout(err.insert1);
  1874.     cout << "\" was found in type \"";
  1875.     if (NotDot(err.insert2))
  1876.     {
  1877.         Unicode::Cout(err.insert2);
  1878.         cout << "/";
  1879.     }
  1880.     Unicode::Cout(err.insert3);
  1881.     cout << "\". However, there is an accessible field \"";
  1882.     Unicode::Cout(err.insert4);
  1883.     cout << "\" whose name closely matches the name \"";
  1884.     Unicode::Cout(err.insert1);
  1885.     cout << "\"";
  1886.  
  1887.     return;
  1888. }
  1889.  
  1890.  
  1891. void SemanticError::PrintFIELD_WITH_PRIVATE_ACCESS_NOT_ACCESSIBLE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1892. {
  1893.     cout << "The field \"";
  1894.     Unicode::Cout(err.insert1);
  1895.     cout << "\" contained in class \"";
  1896.     if (NotDot(err.insert2))
  1897.     {
  1898.         Unicode::Cout(err.insert2);
  1899.         cout << "/";
  1900.     }
  1901.     Unicode::Cout(err.insert3);
  1902.     cout << "\" has private access. Therefore, it is not accessible in class \"";
  1903.     if (NotDot(err.insert4))
  1904.     {
  1905.         Unicode::Cout(err.insert4);
  1906.         cout << "/";
  1907.     }
  1908.     Unicode::Cout(err.insert5);
  1909.     cout << "\"";
  1910.  
  1911.     return;
  1912. }
  1913.  
  1914.  
  1915. void SemanticError::PrintFIELD_WITH_DEFAULT_ACCESS_NOT_ACCESSIBLE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1916. {
  1917.     cout << "The field \"";
  1918.     Unicode::Cout(err.insert1);
  1919.     cout << "\" contained in class \"";
  1920.     if (NotDot(err.insert2))
  1921.     {
  1922.         Unicode::Cout(err.insert2);
  1923.         cout << "/";
  1924.     }
  1925.     Unicode::Cout(err.insert3);
  1926.     cout << "\" has default access. Therefore, it is not accessible in class \"";
  1927.     if (NotDot(err.insert4))
  1928.     {
  1929.         Unicode::Cout(err.insert4);
  1930.         cout << "/";
  1931.     }
  1932.     Unicode::Cout(err.insert5);
  1933.     cout << "\" which is in a different package";
  1934.  
  1935.     return;
  1936. }
  1937.  
  1938.  
  1939. void SemanticError::PrintNAME_NOT_FOUND(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1940. {
  1941.     cout << "No entity named \"";
  1942.     Unicode::Cout(err.insert1);
  1943.     cout << "\" was found in this environment";
  1944.  
  1945.     return;
  1946. }
  1947.  
  1948.  
  1949. void SemanticError::PrintNAME_NOT_YET_AVAILABLE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1950. {
  1951.     cout << "Illegal use of name \"";
  1952.     Unicode::Cout(err.insert1);
  1953.     cout << "\" which has not yet been fully declared at this point";
  1954.  
  1955.     return;
  1956. }
  1957.  
  1958.  
  1959. void SemanticError::PrintNAME_NOT_VARIABLE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1960. {
  1961.     cout << "The name \"";
  1962.     Unicode::Cout(err.insert1);
  1963.     cout << "\" does not denote a valid variable. If \"";
  1964.     Unicode::Cout(err.insert1);
  1965.     cout << "\" is a method that takes no argument, it must be followed by \"()\"";
  1966.  
  1967.     return;
  1968. }
  1969.  
  1970.  
  1971. void SemanticError::PrintMETHOD_NOT_FOUND(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1972. {
  1973.     cout << "No match was found for method \"";
  1974.     Unicode::Cout(err.insert1);
  1975.     cout << "\"";
  1976.  
  1977.     return;
  1978. }
  1979.  
  1980.  
  1981. void SemanticError::PrintMETHOD_NAME_NOT_FOUND_IN_TYPE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1982. {
  1983.     cout << "No method named \"";
  1984.     Unicode::Cout(err.insert1);
  1985.     cout << "\" was found in type \"";
  1986.     if (NotDot(err.insert2))
  1987.     {
  1988.         Unicode::Cout(err.insert2);
  1989.         cout << "/";
  1990.     }
  1991.     Unicode::Cout(err.insert3);
  1992.     cout << "\"";
  1993.  
  1994.     return;
  1995. }
  1996.  
  1997.  
  1998. void SemanticError::PrintMETHOD_NAME_MISSPELLED(ErrorInfo &err, LexStream *lex_stream, Control &control)
  1999. {
  2000.     cout << "No method named \"";
  2001.     Unicode::Cout(err.insert1);
  2002.     cout << "\" was found in type \"";
  2003.     if (NotDot(err.insert2))
  2004.     {
  2005.         Unicode::Cout(err.insert2);
  2006.         cout << "/";
  2007.     }
  2008.     Unicode::Cout(err.insert3);
  2009.     cout << "\". However, there is an accessible method \"";
  2010.     Unicode::Cout(err.insert4);
  2011.     cout << "\" whose name closely matches the name \"";
  2012.     Unicode::Cout(err.insert1);
  2013.     cout << "\"";
  2014.  
  2015.     return;
  2016. }
  2017.  
  2018.  
  2019. void SemanticError::PrintMETHOD_WITH_PRIVATE_ACCESS_NOT_ACCESSIBLE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2020. {
  2021.     cout << "Method \"";
  2022.     Unicode::Cout(err.insert1);
  2023.     cout << "\" in class \"";
  2024.     if (NotDot(err.insert2))
  2025.     {
  2026.         Unicode::Cout(err.insert2);
  2027.         cout << "/";
  2028.     }
  2029.     Unicode::Cout(err.insert3);
  2030.     cout << "\" has private access. Therefore, it is not accessible in class \"";
  2031.     if (NotDot(err.insert4))
  2032.     {
  2033.         Unicode::Cout(err.insert4);
  2034.         cout << "/";
  2035.     }
  2036.     Unicode::Cout(err.insert5);
  2037.     cout << "\"";
  2038.  
  2039.     return;
  2040. }
  2041.  
  2042.  
  2043. void SemanticError::PrintMETHOD_WITH_DEFAULT_ACCESS_NOT_ACCESSIBLE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2044. {
  2045.     cout << "Method \"";
  2046.     Unicode::Cout(err.insert1);
  2047.     cout << "\" in class \"";
  2048.     if (NotDot(err.insert2))
  2049.     {
  2050.         Unicode::Cout(err.insert2);
  2051.         cout << "/";
  2052.     }
  2053.     Unicode::Cout(err.insert3);
  2054.     cout << "\" has default access. Therefore, it is not accessible in class \"";
  2055.     if (NotDot(err.insert4))
  2056.     {
  2057.         Unicode::Cout(err.insert4);
  2058.         cout << "/";
  2059.     }
  2060.     Unicode::Cout(err.insert5);
  2061.     cout << "\" which is in a different package";
  2062.  
  2063.     return;
  2064. }
  2065.  
  2066.  
  2067. void SemanticError::PrintHIDDEN_METHOD_IN_ENCLOSING_CLASS(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2068. {
  2069.     cout << "The method \"";
  2070.     Unicode::Cout(err.insert1);
  2071.     cout << "\" contained in the enclosing type \"";
  2072.     if (NotDot(err.insert2))
  2073.     {
  2074.         Unicode::Cout(err.insert2);
  2075.         cout << "/";
  2076.     }
  2077.     Unicode::Cout(err.insert3);
  2078.     cout << "\" is a perfect match for this method call."
  2079.             " However, it is not visible in this nested class because a method with the same name is hiding it";
  2080.  
  2081.     return;
  2082. }
  2083.  
  2084.  
  2085. void SemanticError::PrintFIELD_NOT_METHOD(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2086. {
  2087.     cout << "The name \"";
  2088.     Unicode::Cout(err.insert1);
  2089.     cout << "\" is not a method name but the name of a field member of the type \"";
  2090.     if (NotDot(err.insert2))
  2091.     {
  2092.         Unicode::Cout(err.insert2);
  2093.         cout << "/";
  2094.     }
  2095.     Unicode::Cout(err.insert3);
  2096.     cout << "\"";
  2097.  
  2098.     return;
  2099. }
  2100.  
  2101.  
  2102. void SemanticError::PrintTYPE_NOT_METHOD(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2103. {
  2104.     cout << "The keyword \"new\" is expected before this expression as \"";
  2105.     Unicode::Cout(err.insert1);
  2106.     cout << "\" is not the name of a method but the name of a type";
  2107.  
  2108.     return;
  2109. }
  2110.  
  2111.  
  2112. void SemanticError::PrintTYPE_NOT_FIELD(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2113. {
  2114.     cout << "A type \"";
  2115.     Unicode::Cout(err.insert1);
  2116.     cout << "\" was found where a field name or method call was expected. Did you mean to write \"";
  2117.     Unicode::Cout(err.insert1);
  2118.     cout << ".xxx\", or \"new ";
  2119.     Unicode::Cout(err.insert1);
  2120.     cout << "()\", or ... ?";
  2121.  
  2122.     return;
  2123. }
  2124.  
  2125.  
  2126. void SemanticError::PrintMETHOD_NOT_FIELD(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2127. {
  2128.     cout << "The name \"";
  2129.     Unicode::Cout(err.insert1);
  2130.     cout << "\" is not a field name but the name of a method declared in the type \"";
  2131.     if (NotDot(err.insert2))
  2132.     {
  2133.         Unicode::Cout(err.insert2);
  2134.         cout << "/";
  2135.     }
  2136.     Unicode::Cout(err.insert3);
  2137.     cout << "\"";
  2138.  
  2139.     return;
  2140. }
  2141.  
  2142.  
  2143. void SemanticError::PrintAMBIGUOUS_CONSTRUCTOR_INVOCATION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2144. {
  2145.     cout << "Ambiguous invocation of constructor \"";
  2146.     Unicode::Cout(err.insert1);
  2147.     cout << "\"";
  2148.  
  2149.     return;
  2150. }
  2151.  
  2152.  
  2153. void SemanticError::PrintAMBIGUOUS_METHOD_INVOCATION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2154. {
  2155.     cout << "Ambiguous invocation of method \"";
  2156.     Unicode::Cout(err.insert1);
  2157.     cout << "\". At least two methods are accessible from here: Method \"";
  2158.     Unicode::Cout(err.insert2);
  2159.     cout << "\" declared in type \"";
  2160.     if (NotDot(err.insert3))
  2161.     {
  2162.         Unicode::Cout(err.insert3);
  2163.         cout << '/';
  2164.     }
  2165.     Unicode::Cout(err.insert4);
  2166.     cout << "\" and method \"";
  2167.     Unicode::Cout(err.insert5);
  2168.     cout << "\" declared in type \"";
  2169.     if (NotDot(err.insert6))
  2170.     {
  2171.         Unicode::Cout(err.insert6);
  2172.         cout << '/';
  2173.     }
  2174.     Unicode::Cout(err.insert7);
  2175.     cout << "\"";
  2176.  
  2177.     return;
  2178. }
  2179.  
  2180.  
  2181. void SemanticError::PrintNAME_NOT_CLASS_VARIABLE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2182. {
  2183.     cout << "The name \"";
  2184.     Unicode::Cout(err.insert1);
  2185.     cout << "\" does not denote a class (static) variable";
  2186.  
  2187.     return;
  2188. }
  2189.  
  2190.  
  2191. void SemanticError::PrintNOT_A_NUMERIC_VARIABLE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2192. {
  2193.     cout << "Only a variable of numeric type can appear in this context";
  2194.  
  2195.     return;
  2196. }
  2197.  
  2198.  
  2199. void SemanticError::PrintMETHOD_NOT_CLASS_METHOD(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2200. {
  2201.     cout << "The method \"";
  2202.     Unicode::Cout(err.insert1);
  2203.     cout << "\" does not denote a class method";
  2204.  
  2205.     return;
  2206. }
  2207.  
  2208.  
  2209. void SemanticError::PrintABSTRACT_TYPE_CREATION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2210. {
  2211.     cout << "Attempt to instantiate an abstract class \"";
  2212.     Unicode::Cout(err.insert1);
  2213.     cout << "\"";
  2214.  
  2215.     return;
  2216. }
  2217.  
  2218.  
  2219. void SemanticError::PrintCONSTRUCTOR_NOT_FOUND(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2220. {
  2221.     cout << "No match was found for constructor \"";
  2222.     Unicode::Cout(err.insert1);
  2223.     cout << "\"";
  2224.  
  2225.     return;
  2226. } 
  2227.  
  2228.  
  2229. void SemanticError::PrintMETHOD_FOUND_FOR_CONSTRUCTOR(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2230. {
  2231.     cout << "No match was found for constructor \"";
  2232.     Unicode::Cout(err.insert1);
  2233.     cout << "\". However, a method with the same name was found at location ";
  2234.     Unicode::Cout(err.insert2);
  2235.  
  2236.     return;
  2237. } 
  2238.  
  2239.  
  2240. void SemanticError::PrintINCOMPATIBLE_TYPE_FOR_INITIALIZATION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2241. {
  2242.     cout << "The type of the left-hand side (or array type) in this initialization (or array creation expression), \"";
  2243.     if (NotDot(err.insert1))
  2244.     {
  2245.         Unicode::Cout(err.insert1);
  2246.         cout << '/';
  2247.     }
  2248.     Unicode::Cout(err.insert2);
  2249.     cout << "\", is not compatible with the type of the right-hand side expression, \"";
  2250.     if (NotDot(err.insert3))
  2251.     {
  2252.         Unicode::Cout(err.insert3);
  2253.         cout << '/';
  2254.     }
  2255.     Unicode::Cout(err.insert4);
  2256.     cout << "\"";
  2257.  
  2258.     return;
  2259. }
  2260.  
  2261.  
  2262. void SemanticError::PrintINCOMPATIBLE_TYPE_FOR_ASSIGNMENT(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2263. {
  2264.     cout << "The type of the left-hand side in this assignment, \"";
  2265.     if (NotDot(err.insert1))
  2266.     {
  2267.         Unicode::Cout(err.insert1);
  2268.         cout << '/';
  2269.     }
  2270.     Unicode::Cout(err.insert2);
  2271.     cout << "\", is not compatible with the type of the right-hand side expression, \"";
  2272.     if (NotDot(err.insert3))
  2273.     {
  2274.         Unicode::Cout(err.insert3);
  2275.         cout << '/';
  2276.     }
  2277.     Unicode::Cout(err.insert4);
  2278.     cout << "\"";
  2279.  
  2280.     return;
  2281. }
  2282.  
  2283.  
  2284. void SemanticError::PrintINCOMPATIBLE_TYPE_FOR_CONDITIONAL_EXPRESSION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2285. {
  2286.     cout << "In this conditional expression, the type of the false subexpression, \"";
  2287.     if (NotDot(err.insert1))
  2288.     {
  2289.         Unicode::Cout(err.insert1);
  2290.         cout << '/';
  2291.     }
  2292.     Unicode::Cout(err.insert2);
  2293.     cout << "\", is not compatible with the type of the true subexpression, \"";
  2294.     if (NotDot(err.insert3))
  2295.     {
  2296.         Unicode::Cout(err.insert3);
  2297.         cout << '/';
  2298.     }
  2299.     Unicode::Cout(err.insert4);
  2300.     cout << "\"";
  2301.  
  2302.     return;
  2303. }
  2304.  
  2305.  
  2306. void SemanticError::PrintVOID_ARRAY(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2307. {
  2308.     cout << "Arrays of type \"void\" are not legal";
  2309.  
  2310.     return;
  2311. }
  2312.  
  2313.  
  2314. void SemanticError::PrintVOID_TYPE_IN_EQUALITY_EXPRESSION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2315. {
  2316.     cout << "Subexpressions of type \"void\" may not appear in an EqualityExpression";
  2317.  
  2318.     return;
  2319. }
  2320.  
  2321.  
  2322. void SemanticError::PrintINCOMPATIBLE_TYPE_FOR_BINARY_EXPRESSION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2323. {
  2324.     cout << "The type of the left-hand side expression, \"";
  2325.     if (NotDot(err.insert1))
  2326.     {
  2327.         Unicode::Cout(err.insert1);
  2328.         cout << '/';
  2329.     }
  2330.     Unicode::Cout(err.insert2);
  2331.     cout << "\", is not compatible with the type of the right-hand side expression, \"";
  2332.     if (NotDot(err.insert3))
  2333.     {
  2334.         Unicode::Cout(err.insert3);
  2335.         cout << '/';
  2336.     }
  2337.     Unicode::Cout(err.insert4);
  2338.     cout << "\" (and vice-versa)";
  2339.  
  2340.     return;
  2341. }
  2342.  
  2343.  
  2344. void SemanticError::PrintINVALID_INSTANCEOF_CONVERSION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2345. {
  2346.     cout << "The type of the left-side expression, \"";
  2347.     if (NotDot(err.insert1))
  2348.     {
  2349.         Unicode::Cout(err.insert1);
  2350.         cout << '/';
  2351.     }
  2352.     Unicode::Cout(err.insert2);
  2353.     cout << "\", cannot possibly be an instance of type \"";
  2354.     if (NotDot(err.insert3))
  2355.     {
  2356.         Unicode::Cout(err.insert3);
  2357.         cout << '/';
  2358.     }
  2359.     Unicode::Cout(err.insert4);
  2360.     cout << "\"";
  2361.  
  2362.     return;
  2363. }
  2364.  
  2365.  
  2366. void SemanticError::PrintINVALID_CAST_CONVERSION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2367. {
  2368.     cout << "An expression of type \"";
  2369.     Unicode::Cout(err.insert1);
  2370.     cout << "\" cannot be cast into type \"";
  2371.     Unicode::Cout(err.insert2);
  2372.     cout << "\"";
  2373.  
  2374.     return;
  2375. }
  2376.  
  2377.  
  2378. void SemanticError::PrintINVALID_CAST_TYPE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2379. {
  2380.     cout << "Expression found where a type is expected";
  2381.  
  2382.     return;
  2383. }
  2384.  
  2385.  
  2386. void SemanticError::PrintTYPE_NOT_PRIMITIVE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2387. {
  2388.     cout << "The type of this expression, \"";
  2389.     Unicode::Cout(err.insert1);
  2390.     cout << "\", is not a primitive type";
  2391.  
  2392.     return;
  2393. }
  2394.  
  2395.  
  2396. void SemanticError::PrintTYPE_NOT_INTEGRAL(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2397. {
  2398.     cout << "The type of this expression, \"";
  2399.     Unicode::Cout(err.insert1);
  2400.     cout << "\", is not an integral type";
  2401.  
  2402.     return;
  2403. }
  2404.  
  2405.  
  2406. void SemanticError::PrintTYPE_NOT_NUMERIC(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2407. {
  2408.     cout << "The type of this expression, \"";
  2409.     Unicode::Cout(err.insert1);
  2410.     cout << "\", is not numeric";
  2411.  
  2412.     return;
  2413. }
  2414.  
  2415.  
  2416. void SemanticError::PrintTYPE_NOT_INTEGER(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2417. {
  2418.     cout << "The type of this expression, \"";
  2419.     Unicode::Cout(err.insert1);
  2420.     cout << "\", cannot be promoted to \"int\" by widening conversion";
  2421.  
  2422.     return;
  2423. }
  2424.  
  2425.  
  2426. void SemanticError::PrintTYPE_NOT_BOOLEAN(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2427. {
  2428.     cout << "The type of this expression, \"";
  2429.     Unicode::Cout(err.insert1);
  2430.     cout << "\", is not boolean";
  2431.  
  2432.     return;
  2433. }
  2434.  
  2435.  
  2436. void SemanticError::PrintTYPE_NOT_ARRAY(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2437. {
  2438.     cout << "The type of this expression, \"";
  2439.     Unicode::Cout(err.insert1);
  2440.     cout << "\", is not an array type";
  2441.  
  2442.     return;
  2443. }
  2444.  
  2445.  
  2446. void SemanticError::PrintTYPE_NOT_REFERENCE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2447. {
  2448.     cout << "The type of this expression, \"";
  2449.     Unicode::Cout(err.insert1);
  2450.     cout << "\", is not a valid reference type in this context";
  2451.  
  2452.     return;
  2453. }
  2454.  
  2455.  
  2456. void SemanticError::PrintTYPE_NOT_VALID_FOR_SWITCH(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2457. {
  2458.     cout << "The type of a switch statement expression must be either \"int\", \"short\", \"char\" or \"byte\".";
  2459.     cout << " The type of this expression is \"";
  2460.     if (NotDot(err.insert1))
  2461.     {
  2462.         Unicode::Cout(err.insert1);
  2463.         cout << '/';
  2464.     }
  2465.     Unicode::Cout(err.insert2);
  2466.     cout << "\"";
  2467.  
  2468.     return;
  2469. }
  2470.  
  2471.  
  2472. void SemanticError::PrintTYPE_IS_VOID(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2473. {
  2474.     cout << "An expression of type \"";
  2475.     Unicode::Cout(err.insert1);
  2476.     cout << "\" is not valid in this context";
  2477.  
  2478.     return;
  2479. }
  2480.  
  2481.  
  2482. void SemanticError::PrintVALUE_NOT_REPRESENTABLE_IN_TYPE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2483. {
  2484.     cout << "The value of this expression cannot be represented in type \"";
  2485.     Unicode::Cout(err.insert1);
  2486.     cout << "\"";
  2487.  
  2488.     return;
  2489. }
  2490.  
  2491.  
  2492. void SemanticError::PrintDUPLICATE_CASE_VALUE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2493. {
  2494.     cout << "The value of this expression, ";
  2495.     Unicode::Cout(err.insert1);
  2496.     cout << ", has already been used in this switch statement";
  2497.  
  2498.     return;
  2499. }
  2500.  
  2501.  
  2502. void SemanticError::PrintMISPLACED_THIS_EXPRESSION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2503. {
  2504.     cout << "A \"this\" expression may only be used in the body of an instance method, "
  2505.             "constructor (after the explicit constructor invocation, if any), "
  2506.             "initializer block, or in the initializer expression of an instance variable";
  2507.  
  2508.     return;
  2509. }
  2510.  
  2511.  
  2512. void SemanticError::PrintMISPLACED_SUPER_EXPRESSION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2513. {
  2514.     cout << "A \"super\" expression may only appear in the body of a class that has a super class and"
  2515.             " it must be enclosed in the body of an instance method or constructor or in the initializer"
  2516.             " of an instance variable";
  2517.  
  2518.     return;
  2519. }
  2520.  
  2521.  
  2522. void SemanticError::PrintFINAL_VARIABLE_TARGET_IN_LOOP(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2523. {
  2524.     cout << "Possible attempt to assign a value to a final variable \"";
  2525.     Unicode::Cout(err.insert1);
  2526.     cout << "\"";
  2527.     cout << ", within the body of a loop that may execute more than once";
  2528.  
  2529.     return;
  2530. }
  2531.  
  2532.  
  2533. void SemanticError::PrintTARGET_VARIABLE_IS_FINAL(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2534. {
  2535.     cout << "Possible attempt to reassign a value to the final variable \"";
  2536.     Unicode::Cout(err.insert1);
  2537.     cout << "\"";
  2538.     if (err.insert2)
  2539.     {
  2540.         cout << ". The other assignement was at location ";
  2541.         Unicode::Cout(err.insert2);
  2542.     }
  2543.  
  2544.     return;
  2545. }
  2546.  
  2547.  
  2548. void SemanticError::PrintUNINITIALIZED_FINAL_VARIABLE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2549. {
  2550.     cout << "A final variable must be initialized";
  2551.  
  2552.     return;
  2553. }
  2554.  
  2555.  
  2556. void SemanticError::PrintUNINITIALIZED_STATIC_FINAL_VARIABLE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2557. {
  2558.     cout << "A blank class final variable must be initialized in a static initializer block. It is assumed to be initialized";
  2559.  
  2560.     return;
  2561. }
  2562.  
  2563.  
  2564. void SemanticError::PrintUNINITIALIZED_FINAL_VARIABLE_IN_CONSTRUCTOR(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2565. {
  2566.     cout << "The blank final field \"this.";
  2567.     cout << err.insert1;
  2568.     cout << "\" is not definitely assigned a value in this constructor";
  2569.  
  2570.     return;
  2571. }
  2572.  
  2573.  
  2574. void SemanticError::PrintINIT_SCALAR_WITH_ARRAY(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2575. {
  2576.     cout << "An array initializer cannot be used to initialize a variable of type \"";
  2577.     Unicode::Cout(err.insert1);
  2578.     cout << "\"";
  2579.  
  2580.     return;
  2581. }
  2582.  
  2583.  
  2584. void SemanticError::PrintINIT_ARRAY_WITH_SCALAR(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2585. {
  2586.     cout << "A single expression cannot be used to initialize an array variable of type \"";
  2587.     Unicode::Cout(err.insert1);
  2588.     cout << "\"";
  2589.  
  2590.     return;
  2591. }
  2592.  
  2593.  
  2594. void SemanticError::PrintINVALID_BYTE_VALUE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2595. {
  2596.     cout << "A byte value must be an integer value (note that a character literal is not an integer value) in the range -128..127";
  2597.  
  2598.     return;
  2599. }
  2600.  
  2601.  
  2602. void SemanticError::PrintINVALID_SHORT_VALUE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2603. {
  2604.     cout << "A short value must be an integer value (note that a character literal is not an integer value) in the range -32768..32767";
  2605.  
  2606.     return;
  2607. }
  2608.  
  2609.  
  2610. void SemanticError::PrintINVALID_CHARACTER_VALUE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2611. {
  2612.     cout << "A character literal must be a valid unicode value - i.e., a character literal enclosed in single quotes or "
  2613.             "an integer value in the range 0..65535 or an escaped 3-digit octal value in the range \\000..\\377";
  2614.  
  2615.     return;
  2616. }
  2617.  
  2618.  
  2619. void SemanticError::PrintINVALID_INT_VALUE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2620. {
  2621.     cout << "The value of an \"int\" literal must be a decimal value in the range -2147483648..2147483647"
  2622.             " or a hexadecimal or octal literal that fits in 32 bits";
  2623.  
  2624.     return;
  2625. }
  2626.  
  2627.  
  2628. void SemanticError::PrintINVALID_LONG_VALUE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2629. {
  2630.     cout << "The value of a long literal must be a decimal value in the range "
  2631.             "-9223372036854775808..9223372036854775807 or a hexadecimal or octal literal that fits in 64 bits";
  2632.  
  2633.     return;
  2634. }
  2635.  
  2636.  
  2637. void SemanticError::PrintINVALID_FLOAT_VALUE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2638. {
  2639.     cout << "Invalid floating-point constant";
  2640.  
  2641.     return;
  2642. }
  2643.  
  2644.  
  2645. void SemanticError::PrintINVALID_DOUBLE_VALUE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2646. {
  2647.     cout << "Invalid double constant";
  2648.  
  2649.     return;
  2650. }
  2651.  
  2652.  
  2653. void SemanticError::PrintINVALID_STRING_VALUE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2654. {
  2655.     cout << "The value of this \"String\" literal is invalid. Perhaps it contains a bad escape sequence?";
  2656.  
  2657.     return;
  2658. }
  2659.  
  2660.  
  2661. void SemanticError::PrintRETURN_STATEMENT_IN_INITIALIZER(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2662. {
  2663.     cout << "A return statement may not appear in an initializer block";
  2664.  
  2665.     return;
  2666. }
  2667.  
  2668.  
  2669. void SemanticError::PrintMISPLACED_RETURN_WITH_EXPRESSION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2670. {
  2671.     cout << "A return statement with expression must be contained in a method declaration that is "
  2672.             "declared to return a value";
  2673.  
  2674.     return;
  2675. }
  2676.  
  2677.  
  2678. void SemanticError::PrintMISPLACED_RETURN_WITH_NO_EXPRESSION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2679. {
  2680.     cout << "A return statement with no expression may only appear in void method or a constructor";
  2681.  
  2682.     return;
  2683. }
  2684.  
  2685.  
  2686. void SemanticError::PrintMISMATCHED_RETURN_AND_METHOD_TYPE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2687. {
  2688.     cout << "The type of this return expression, \"";
  2689.     if (NotDot(err.insert1))
  2690.     {
  2691.         Unicode::Cout(err.insert1);
  2692.         cout << '/';
  2693.     }
  2694.     Unicode::Cout(err.insert2);
  2695.     cout << "\", does not match the return type of the method, \"";
  2696.     if (NotDot(err.insert3))
  2697.     {
  2698.         Unicode::Cout(err.insert3);
  2699.         cout << '/';
  2700.     }
  2701.     Unicode::Cout(err.insert4);
  2702.     cout << "\"";
  2703.  
  2704.     return;
  2705. }
  2706.  
  2707.  
  2708. void SemanticError::PrintEXPRESSION_NOT_THROWABLE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2709. {
  2710.     cout << "The expression in a throw statement must denote a variable or value of a reference type "
  2711.             "which is assignable to the type Throwable";
  2712.  
  2713.     return;
  2714. }
  2715.  
  2716.  
  2717. void SemanticError::PrintBAD_THROWABLE_EXPRESSION_IN_TRY(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2718. {
  2719.     cout << "The type of the expression in this throw statement, \"";
  2720.     if (NotDot(err.insert1))
  2721.     {
  2722.         Unicode::Cout(err.insert1);
  2723.         cout << '/';
  2724.     }
  2725.     Unicode::Cout(err.insert2);
  2726.     cout << "\", is not catchable by the enclosing try statement;";
  2727.     if (wcslen(err.insert3) > 0)
  2728.     {
  2729.         cout << " nor is it assignable to an exception in the throws clause of the enclosing method or constructor \"";
  2730.         Unicode::Cout(err.insert3);
  2731.         cout << "\";";
  2732.     }
  2733.     cout << " nor is it a subclass of RuntimeException or Error";
  2734.  
  2735.     return;
  2736. }
  2737.  
  2738.  
  2739. void SemanticError::PrintBAD_THROWABLE_EXPRESSION_IN_METHOD(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2740. {
  2741.     cout << "The type of the expression in this throw statement, \"";
  2742.     if (NotDot(err.insert1))
  2743.     {
  2744.         Unicode::Cout(err.insert1);
  2745.         cout << '/';
  2746.     }
  2747.     Unicode::Cout(err.insert2);
  2748.     cout << "\", is not assignable to an exception in the throws clause of the enclosing method or constructor \"";
  2749.     Unicode::Cout(err.insert3);
  2750.     cout << "\"; nor is it a subclass of RuntimeException or Error";
  2751.  
  2752.     return;
  2753. }
  2754.  
  2755.  
  2756. void SemanticError::PrintBAD_THROWABLE_EXPRESSION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2757. {
  2758.     cout << "The type of the expression in this throw statement, \"";
  2759.     if (NotDot(err.insert1))
  2760.     {
  2761.         Unicode::Cout(err.insert1);
  2762.         cout << '/';
  2763.     }
  2764.     Unicode::Cout(err.insert2);
  2765.     cout << "\", is not a subclass of RuntimeException or Error";
  2766.  
  2767.     return;
  2768. }
  2769.  
  2770.  
  2771. void SemanticError::PrintMISPLACED_BREAK_STATEMENT(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2772. {
  2773.     cout << "A \"break\" statement must be enclosed in a \"switch\", \"while\", \"do\" or \"for\" statement";
  2774.  
  2775.     return;
  2776. }
  2777.  
  2778.  
  2779. void SemanticError::PrintMISPLACED_CONTINUE_STATEMENT(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2780. {
  2781.     cout << "A \"continue\" statement must be enclosed in a \"while\", \"do\" or \"for\" statement";
  2782.  
  2783.     return;
  2784. }
  2785.  
  2786.  
  2787. void SemanticError::PrintMISPLACED_EXPLICIT_CONSTRUCTOR_INVOCATION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2788. {
  2789.     cout << "Misplaced explicit constructor invocation";
  2790.  
  2791.     return;
  2792. }
  2793.  
  2794.  
  2795. void SemanticError::PrintINVALID_CONTINUE_TARGET(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2796. {
  2797.     cout << "The statement labeled \"";
  2798.     Unicode::Cout(err.insert1);
  2799.     cout << "\" cannot be continued since it is not a \"while\", \"do\" or \"for\" statement";
  2800.  
  2801.     return;
  2802. }
  2803.  
  2804.  
  2805. void SemanticError::PrintNON_ABSTRACT_TYPE_CONTAINS_ABSTRACT_METHOD(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2806. {
  2807.     cout << "The abstract method \"";
  2808.     Unicode::Cout(err.insert1);
  2809.     cout << "\" is enclosed in a type, \"";
  2810.     Unicode::Cout(err.insert2);
  2811.     cout << "\", that is not abstract";
  2812.  
  2813.     return;
  2814. }
  2815.  
  2816.  
  2817. void SemanticError::PrintNON_ABSTRACT_TYPE_INHERITS_ABSTRACT_METHOD(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2818. {
  2819.     cout << "The abstract method \"";
  2820.     Unicode::Cout(err.insert1);
  2821.     cout << "\", inherited from class \"";
  2822.     if (NotDot(err.insert2))
  2823.     {
  2824.         Unicode::Cout(err.insert2);
  2825.         cout << '/';
  2826.     }
  2827.     Unicode::Cout(err.insert3);
  2828.     cout << "\", is not implemented in the non-abstract class \"";
  2829.     if (NotDot(err.insert4))
  2830.     {
  2831.         Unicode::Cout(err.insert4);
  2832.         cout << '/';
  2833.     }
  2834.     Unicode::Cout(err.insert5);
  2835.     cout << "\"";
  2836.  
  2837.     return;
  2838. }
  2839.  
  2840.  
  2841. void SemanticError::PrintNON_ABSTRACT_TYPE_INHERITS_ABSTRACT_METHOD_FROM_ABSTRACT_CLASS(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2842. {
  2843.     cout << "The abstract method \"";
  2844.     Unicode::Cout(err.insert1);
  2845.     cout << "\", inherited from class \"";
  2846.     if (NotDot(err.insert2))
  2847.     {
  2848.         Unicode::Cout(err.insert2);
  2849.         cout << '/';
  2850.     }
  2851.     Unicode::Cout(err.insert3);
  2852.     cout << "\", is not implemented in the non-abstract class \"";
  2853.     if (NotDot(err.insert4))
  2854.     {
  2855.         Unicode::Cout(err.insert4);
  2856.         cout << '/';
  2857.     }
  2858.     Unicode::Cout(err.insert5);
  2859.     cout << "\". Since the type \"";
  2860.     if (NotDot(err.insert2))
  2861.     {
  2862.         Unicode::Cout(err.insert2);
  2863.         cout << '/';
  2864.     }
  2865.     Unicode::Cout(err.insert3);
  2866.     cout << "\" was read from a class file, it is possible that it just needs to be recompiled "
  2867.             "because after having inherited method \"";
  2868.     Unicode::Cout(err.insert1);
  2869.     cout << "\" from an interface, the method was subsequently removed from that interface.";
  2870.  
  2871.     return;
  2872. }
  2873.  
  2874.  
  2875. void SemanticError::PrintNON_ABSTRACT_TYPE_CANNOT_OVERRIDE_DEFAULT_ABSTRACT_METHOD(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2876. {
  2877.     cout << "The abstract method \"";
  2878.     Unicode::Cout(err.insert1);
  2879.     cout << "\", belonging to the class \"";
  2880.     if (NotDot(err.insert2))
  2881.     {
  2882.         Unicode::Cout(err.insert2);
  2883.         cout << '/';
  2884.     }
  2885.     Unicode::Cout(err.insert3);
  2886.     cout << "\" has default access."
  2887.             " Therefore, it is not inherited and hence, it cannot be implemented in the non-abstract class \"";
  2888.     if (NotDot(err.insert4))
  2889.     {
  2890.         Unicode::Cout(err.insert4);
  2891.         cout << '/';
  2892.     }
  2893.     Unicode::Cout(err.insert5);
  2894.     cout << "\"";
  2895.  
  2896.     return;
  2897. }
  2898.  
  2899.  
  2900. void SemanticError::PrintNO_ABSTRACT_METHOD_IMPLEMENTATION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2901. {
  2902.     cout << "No implementation of the abstract method \"";
  2903.     Unicode::Cout(err.insert1);
  2904.     cout << "\" declared in type \"";
  2905.     if (NotDot(err.insert2))
  2906.     {
  2907.         Unicode::Cout(err.insert2);
  2908.         cout << '/';
  2909.     }
  2910.     Unicode::Cout(err.insert3);
  2911.     cout << "\" was found in class \"";
  2912.     Unicode::Cout(err.insert4);
  2913.     cout << "\"";
  2914.  
  2915.     return;
  2916. }
  2917.  
  2918.  
  2919. void SemanticError::PrintDUPLICATE_INTERFACE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2920. {
  2921.     cout << "Duplicate specification of interface \"";
  2922.     if (NotDot(err.insert1))
  2923.     {
  2924.         Unicode::Cout(err.insert1);
  2925.         cout << '/';
  2926.     }
  2927.     Unicode::Cout(err.insert2);
  2928.     cout << "\" in definition of type \"";
  2929.     Unicode::Cout(err.insert3);
  2930.     cout << "\"";
  2931.  
  2932.     return;
  2933. }
  2934.  
  2935.  
  2936. void SemanticError::PrintUNKNOWN_QUALIFIED_NAME_BASE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2937. {
  2938.     cout << "\"";
  2939.     Unicode::Cout(err.insert1);
  2940.     cout << "\" is either a misplaced package name or a non-existent entity.";
  2941.  
  2942.     return;
  2943. }
  2944.  
  2945.  
  2946. void SemanticError::PrintUNKNOWN_AMBIGUOUS_NAME(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2947. {
  2948.     cout << "\"";
  2949.     Unicode::Cout(err.insert1);
  2950.     cout << "\" is either a misplaced package name or a non-existent entity. An expression name is expected in this context";
  2951.  
  2952.     return;
  2953. }
  2954.  
  2955.  
  2956. void SemanticError::PrintCIRCULAR_CLASS(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2957. {
  2958.     cout << "The class \"";
  2959.     if (NotDot(err.insert1))
  2960.     {
  2961.         Unicode::Cout(err.insert1);
  2962.         cout << "/";
  2963.     }
  2964.     Unicode::Cout(err.insert2);
  2965.     cout << "\" is circularly defined with its super type(s)";
  2966.  
  2967.     return;
  2968. }
  2969.  
  2970.  
  2971. void SemanticError::PrintCIRCULAR_INTERFACE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2972. {
  2973.     cout << "The interface \"";
  2974.     if (NotDot(err.insert1))
  2975.     {
  2976.         Unicode::Cout(err.insert1);
  2977.         cout << "/";
  2978.     }
  2979.     Unicode::Cout(err.insert2);
  2980.     cout << "\" is circularly defined with its super type(s)";
  2981.  
  2982.     return;
  2983. }
  2984.  
  2985.  
  2986. void SemanticError::PrintTYPE_NOT_ACCESSIBLE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  2987. {
  2988.     cout << "The type \"";
  2989.     if (NotDot(err.insert1))
  2990.     {
  2991.         Unicode::Cout(err.insert1);
  2992.         cout << '/';
  2993.     }
  2994.     Unicode::Cout(err.insert2);
  2995.     cout << "\" with ";
  2996.     Unicode::Cout(err.insert3);
  2997.     cout << " access is not visible here";
  2998.  
  2999.     return;
  3000. }
  3001.  
  3002.  
  3003. void SemanticError::PrintPRIVATE_FIELD_NOT_ACCESSIBLE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3004. {
  3005.     cout << "The field \"";
  3006.     Unicode::Cout(err.insert1);
  3007.     cout << "\" in type \"";
  3008.     if (NotDot(err.insert2))
  3009.     {
  3010.         Unicode::Cout(err.insert2);
  3011.         cout << '/';
  3012.     }
  3013.     Unicode::Cout(err.insert3);
  3014.     cout << "\" is private and not accessible here";
  3015.  
  3016.     return;
  3017. }
  3018.  
  3019.  
  3020. void SemanticError::PrintPROTECTED_FIELD_NOT_ACCESSIBLE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3021. {
  3022.     cout << "The field \"";
  3023.     Unicode::Cout(err.insert1);
  3024.     cout << "\" in type \"";
  3025.     if (NotDot(err.insert2))
  3026.     {
  3027.         Unicode::Cout(err.insert2);
  3028.         cout << '/';
  3029.     }
  3030.     Unicode::Cout(err.insert3);
  3031.     cout << "\" is protected and not accessible here";
  3032.  
  3033.     return;
  3034. }
  3035.  
  3036.  
  3037. void SemanticError::PrintDEFAULT_FIELD_NOT_ACCESSIBLE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3038. {
  3039.     cout << "The field \"";
  3040.     Unicode::Cout(err.insert1);
  3041.     cout << "\" in type \"";
  3042.     if (NotDot(err.insert2))
  3043.     {
  3044.         Unicode::Cout(err.insert2);
  3045.         cout << '/';
  3046.     }
  3047.     Unicode::Cout(err.insert3);
  3048.     cout << "\" has default access and is not accessible here";
  3049.  
  3050.     return;
  3051. }
  3052.  
  3053.  
  3054. void SemanticError::PrintPRIVATE_METHOD_NOT_ACCESSIBLE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3055. {
  3056.     cout << "Method \"";
  3057.     Unicode::Cout(err.insert1);
  3058.     cout << "\" in type \"";
  3059.     if (NotDot(err.insert2))
  3060.     {
  3061.         Unicode::Cout(err.insert2);
  3062.         cout << '/';
  3063.     }
  3064.     Unicode::Cout(err.insert3);
  3065.     cout << "\" is private and not accessible here";
  3066.  
  3067.     return;
  3068. }
  3069.  
  3070.  
  3071. void SemanticError::PrintPROTECTED_METHOD_NOT_ACCESSIBLE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3072. {
  3073.     cout << "Method \"";
  3074.     Unicode::Cout(err.insert1);
  3075.     cout << "\" in type \"";
  3076.     if (NotDot(err.insert2))
  3077.     {
  3078.         Unicode::Cout(err.insert2);
  3079.         cout << '/';
  3080.     }
  3081.     Unicode::Cout(err.insert3);
  3082.     cout << "\" is protected and not accessible here";
  3083.  
  3084.     return;
  3085. }
  3086.  
  3087.  
  3088. void SemanticError::PrintDEFAULT_METHOD_NOT_ACCESSIBLE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3089. {
  3090.     cout << "Method \"";
  3091.     Unicode::Cout(err.insert1);
  3092.     cout << "\" in type \"";
  3093.     if (NotDot(err.insert2))
  3094.     {
  3095.         Unicode::Cout(err.insert2);
  3096.         cout << '/';
  3097.     }
  3098.     Unicode::Cout(err.insert3);
  3099.     cout << "\" has default access and is not accessible here";
  3100.  
  3101.     return;
  3102. }
  3103.  
  3104.  
  3105. void SemanticError::PrintPRIVATE_CONSTRUCTOR_NOT_ACCESSIBLE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3106. {
  3107.     cout << "The constructor \"";
  3108.     Unicode::Cout(err.insert1);
  3109.     cout << "\" in type \"";
  3110.     if (NotDot(err.insert2))
  3111.     {
  3112.         Unicode::Cout(err.insert2);
  3113.         cout << '/';
  3114.     }
  3115.     Unicode::Cout(err.insert3);
  3116.     cout << "\" is private. Therefore, it is not accessible here";
  3117.  
  3118.     return;
  3119. }
  3120.  
  3121.  
  3122. void SemanticError::PrintPROTECTED_CONSTRUCTOR_NOT_ACCESSIBLE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3123. {
  3124.     cout << "The constructor \"";
  3125.     Unicode::Cout(err.insert1);
  3126.     cout << "\" in type \"";
  3127.     if (NotDot(err.insert2))
  3128.     {
  3129.         Unicode::Cout(err.insert2);
  3130.         cout << '/';
  3131.     }
  3132.     Unicode::Cout(err.insert3);
  3133.     cout << "\" is protected. Therefore, it is not accessible here";
  3134.  
  3135.     return;
  3136. }
  3137.  
  3138.  
  3139. void SemanticError::PrintDEFAULT_CONSTRUCTOR_NOT_ACCESSIBLE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3140. {
  3141.     cout << "The constructor \"";
  3142.     Unicode::Cout(err.insert1);
  3143.     cout << "\" in type \"";
  3144.     if (NotDot(err.insert2))
  3145.     {
  3146.         Unicode::Cout(err.insert2);
  3147.         cout << '/';
  3148.     }
  3149.     Unicode::Cout(err.insert3);
  3150.     cout << "\" has default access. Therefore, it is not accessible here";
  3151.  
  3152.     return;
  3153. }
  3154.  
  3155.  
  3156. void SemanticError::PrintCONSTRUCTOR_DOES_NOT_THROW_THIS_EXCEPTION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3157. {
  3158.     cout << "The constructor invoked here can throw the exception \"";
  3159.     if (NotDot(err.insert1))
  3160.     {
  3161.         Unicode::Cout(err.insert1);
  3162.         cout << "/";
  3163.     }
  3164.     Unicode::Cout(err.insert2);
  3165.     cout << "\" which is not thrown by the constructor containing this call";
  3166.  
  3167.     return;
  3168. }
  3169.  
  3170.  
  3171. void SemanticError::PrintCONSTRUCTOR_DOES_NOT_THROW_SUPER_EXCEPTION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3172. {
  3173.     cout << "A constructor associated with this ";
  3174.  
  3175.     if (wcslen(err.insert1) == 0)
  3176.         cout << "anonymous type";
  3177.     else
  3178.     {
  3179.         cout << "type, \"";
  3180.         Unicode::Cout(err.insert1);
  3181.         cout << "\",";
  3182.     }
  3183.  
  3184.     cout << " does not throw the exception \"";
  3185.     if (NotDot(err.insert2))
  3186.     {
  3187.         Unicode::Cout(err.insert2);
  3188.         cout << "/";
  3189.     }
  3190.     Unicode::Cout(err.insert3);
  3191.     cout << "\" thrown by its super type, \"";
  3192.     if (NotDot(err.insert4))
  3193.     {
  3194.         Unicode::Cout(err.insert4);
  3195.         cout << "/";
  3196.     }
  3197.     Unicode::Cout(err.insert5);
  3198.     cout << "\"";
  3199.  
  3200.     return;
  3201. }
  3202.  
  3203.  
  3204. void SemanticError::PrintPARAMETER_REDECLARED(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3205. {
  3206.     cout << "The name of a formal parameter, \"";
  3207.     Unicode::Cout(err.insert1);
  3208.     cout << "\", may not be used to declare a local variable or an exception parameter";
  3209.  
  3210.     return;
  3211. }
  3212.  
  3213.  
  3214. void SemanticError::PrintBAD_ABSTRACT_METHOD_MODIFIER(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3215. {
  3216.     cout << "A method declaration that contains the keyword \"abstract\" may not also contain one of the keywords: "
  3217.             "\"private\", \"static\", \"final\", \"native\" or \"synchronized\"";
  3218.  
  3219.     return;
  3220. }
  3221.  
  3222.  
  3223. void SemanticError::PrintABSTRACT_METHOD_MODIFIER_CONFLICT(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3224. {
  3225.     cout << "An abstract method may not also contain the keyword \"";
  3226.     Unicode::Cout(err.insert1);
  3227.     cout << "\"";
  3228.  
  3229.     return;
  3230. }
  3231.  
  3232.  
  3233. void SemanticError::PrintABSTRACT_METHOD_INVOCATION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3234. {
  3235.     cout << "An abstract method, \"";
  3236.     Unicode::Cout(err.insert1);
  3237.     cout << "\", cannot be invoked";
  3238.  
  3239.     return;
  3240. }
  3241.  
  3242.  
  3243. void SemanticError::PrintFINAL_METHOD_OVERRIDE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3244. {
  3245.     cout << "The method \"";
  3246.     Unicode::Cout(err.insert1);
  3247.     cout << "\" cannot override the final (or private) method \"";
  3248.     Unicode::Cout(err.insert2);
  3249.     cout << "\" declared in type \"";
  3250.     if (NotDot(err.insert3))
  3251.     {
  3252.         Unicode::Cout(err.insert3);
  3253.         cout << "/";
  3254.     }
  3255.     Unicode::Cout(err.insert4);
  3256.     cout << "\"";
  3257.  
  3258.     return;
  3259. }
  3260.  
  3261.  
  3262. void SemanticError::PrintFINAL_METHOD_OVERRIDE_EXTERNALLY(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3263. {
  3264.     cout << "In class \"";
  3265.     Unicode::Cout(err.insert1);
  3266.     cout << "\", the method \"";
  3267.     Unicode::Cout(err.insert2);
  3268.     cout << "\", inherited from type \"";
  3269.     if (NotDot(err.insert3))
  3270.     {
  3271.         Unicode::Cout(err.insert3);
  3272.         cout << "/";
  3273.     }
  3274.     Unicode::Cout(err.insert4);
  3275.     cout << "\", overrides the final (or private) method \"";
  3276.     Unicode::Cout(err.insert5);
  3277.     cout << "\", inherited from type \"";
  3278.     if (NotDot(err.insert6))
  3279.     {
  3280.         Unicode::Cout(err.insert6);
  3281.         cout << "/";
  3282.     }
  3283.     Unicode::Cout(err.insert7);
  3284.     cout << "\"";
  3285.  
  3286.     return;
  3287. }
  3288.  
  3289.  
  3290. void SemanticError::PrintPRIVATE_METHOD_OVERRIDE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3291. {
  3292.     cout << "The method \"";
  3293.     Unicode::Cout(err.insert1);
  3294.     cout << "\" is overriding the private (should be treated as final) method \"";
  3295.     Unicode::Cout(err.insert2);
  3296.     cout << "\" declared in type \"";
  3297.     if (NotDot(err.insert3))
  3298.     {
  3299.         Unicode::Cout(err.insert3);
  3300.         cout << "/";
  3301.     }
  3302.     Unicode::Cout(err.insert4);
  3303.     cout << "\"";
  3304.  
  3305.     return;
  3306. }
  3307.  
  3308.  
  3309. void SemanticError::PrintPRIVATE_METHOD_OVERRIDE_EXTERNALLY(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3310. {
  3311.     cout << "In class \"";
  3312.     Unicode::Cout(err.insert1);
  3313.     cout << "\", the method \"";
  3314.     Unicode::Cout(err.insert2);
  3315.     cout << "\", inherited from type \"";
  3316.     if (NotDot(err.insert3))
  3317.     {
  3318.         Unicode::Cout(err.insert3);
  3319.         cout << "/";
  3320.     }
  3321.     Unicode::Cout(err.insert4);
  3322.     cout << "\", overrides the private (should be treated as final) method \"";
  3323.     Unicode::Cout(err.insert5);
  3324.     cout << "\", inherited from type \"";
  3325.     if (NotDot(err.insert6))
  3326.     {
  3327.         Unicode::Cout(err.insert6);
  3328.         cout << "/";
  3329.     }
  3330.     Unicode::Cout(err.insert7);
  3331.     cout << "\"";
  3332.  
  3333.     return;
  3334. }
  3335.  
  3336.  
  3337. void SemanticError::PrintCLASS_METHOD_OVERRIDE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3338. {
  3339.     cout << "The instance method \"";
  3340.     Unicode::Cout(err.insert1);
  3341.     cout << "\" cannot override the static method \"";
  3342.     Unicode::Cout(err.insert2);
  3343.     cout << "\" declared in type \"";
  3344.     if (NotDot(err.insert3))
  3345.     {
  3346.         Unicode::Cout(err.insert3);
  3347.         cout << "/";
  3348.     }
  3349.     Unicode::Cout(err.insert4);
  3350.     cout << "\"";
  3351.  
  3352.     return;
  3353. }
  3354.  
  3355.  
  3356. void SemanticError::PrintCLASS_METHOD_OVERRIDE_EXTERNALLY(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3357. {
  3358.     cout << "In class \"";
  3359.     Unicode::Cout(err.insert1);
  3360.     cout << "\", the instance method \"";
  3361.     Unicode::Cout(err.insert2);
  3362.     cout << "\", inherited from type \"";
  3363.     if (NotDot(err.insert3))
  3364.     {
  3365.         Unicode::Cout(err.insert3);
  3366.         cout << "/";
  3367.     }
  3368.     Unicode::Cout(err.insert4);
  3369.     cout << "\", cannot override the static method \"";
  3370.     Unicode::Cout(err.insert5);
  3371.     cout << "\", declared in type \"";
  3372.     if (NotDot(err.insert6))
  3373.     {
  3374.         Unicode::Cout(err.insert6);
  3375.         cout << "/";
  3376.     }
  3377.     Unicode::Cout(err.insert7);
  3378.     cout << "\"";
  3379.  
  3380.     return;
  3381. }
  3382.  
  3383.  
  3384. void SemanticError::PrintINSTANCE_METHOD_OVERRIDE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3385. {
  3386.     cout << "The static method \"";
  3387.     Unicode::Cout(err.insert1);
  3388.     cout << "\" cannot hide the instance method \"";
  3389.     Unicode::Cout(err.insert2);
  3390.     cout << "\" declared in \"";
  3391.     if (NotDot(err.insert3))
  3392.     {
  3393.         Unicode::Cout(err.insert3);
  3394.         cout << "/";
  3395.     }
  3396.     Unicode::Cout(err.insert4);
  3397.     cout << "\"";
  3398.  
  3399.     return;
  3400. }
  3401.  
  3402.  
  3403. void SemanticError::PrintINSTANCE_METHOD_OVERRIDE_EXTERNALLY(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3404. {
  3405.     cout << "In class \"";
  3406.     Unicode::Cout(err.insert1);
  3407.     cout << "\", the static method \"";
  3408.     Unicode::Cout(err.insert2);
  3409.     cout << "\", inherited from type \"";
  3410.     if (NotDot(err.insert3))
  3411.     {
  3412.         Unicode::Cout(err.insert3);
  3413.         cout << "/";
  3414.     }
  3415.     Unicode::Cout(err.insert4);
  3416.     cout << "\", hides the instance method \"";
  3417.     Unicode::Cout(err.insert5);
  3418.     cout << "\", declared in type \"";
  3419.     if (NotDot(err.insert6))
  3420.     {
  3421.         Unicode::Cout(err.insert6);
  3422.         cout << "/";
  3423.     }
  3424.     Unicode::Cout(err.insert7);
  3425.     cout << "\"";
  3426.  
  3427.     return;
  3428. }
  3429.  
  3430.  
  3431. void SemanticError::PrintBAD_ACCESS_METHOD_OVERRIDE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3432. {
  3433.     cout << "The method \"";
  3434.     Unicode::Cout(err.insert1);
  3435.     cout << "\" with ";
  3436.     Unicode::Cout(err.insert2);
  3437.     cout << " access cannot override the method \"";
  3438.     Unicode::Cout(err.insert3);
  3439.     cout << "\" with ";
  3440.     Unicode::Cout(err.insert4);
  3441.     cout << " access declared in type \"";
  3442.     if (NotDot(err.insert5))
  3443.     {
  3444.         Unicode::Cout(err.insert5);
  3445.         cout << "/";
  3446.     }
  3447.     Unicode::Cout(err.insert6);
  3448.     cout << "\"";
  3449.  
  3450.     return;
  3451. }
  3452.  
  3453.  
  3454. void SemanticError::PrintBAD_ACCESS_METHOD_OVERRIDE_EXTERNALLY(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3455. {
  3456.     cout << "In class \"";
  3457.     Unicode::Cout(err.insert1);
  3458.     cout << "\", the method \"";
  3459.     Unicode::Cout(err.insert2);
  3460.     cout << "\" with ";
  3461.     Unicode::Cout(err.insert3);
  3462.     cout << " access inherited from type \"";
  3463.     if (NotDot(err.insert4))
  3464.     {
  3465.         Unicode::Cout(err.insert4);
  3466.         cout << "/";
  3467.     }
  3468.     Unicode::Cout(err.insert5);
  3469.     cout << "\", cannot override the method \"";
  3470.     Unicode::Cout(err.insert6);
  3471.     cout << "\" with ";
  3472.     Unicode::Cout(err.insert7);
  3473.     cout << " access inherited from type \"";
  3474.     if (NotDot(err.insert8))
  3475.     {
  3476.         Unicode::Cout(err.insert8);
  3477.         cout << "/";
  3478.     }
  3479.     Unicode::Cout(err.insert9);
  3480.     cout << "\"";
  3481.  
  3482.     return;
  3483. }
  3484.  
  3485.  
  3486. void SemanticError::PrintMISMATCHED_OVERRIDDEN_EXCEPTION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3487. {
  3488.     cout << "The exception \"";
  3489.     Unicode::Cout(err.insert1);
  3490.     cout << "\" is not the same as or a subclass of any exception in the throws clause of the overridden method \"";
  3491.     Unicode::Cout(err.insert2);
  3492.     cout << "\" declared in type \"";
  3493.     if (NotDot(err.insert3))
  3494.     {
  3495.         Unicode::Cout(err.insert3);
  3496.         cout << "/";
  3497.     }
  3498.     Unicode::Cout(err.insert4);
  3499.     cout << "\"";
  3500.  
  3501.     return;
  3502. }
  3503.  
  3504.  
  3505. void SemanticError::PrintMISMATCHED_OVERRIDDEN_EXCEPTION_EXTERNALLY(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3506. {
  3507.     cout << "In class \"";
  3508.     Unicode::Cout(err.insert1);
  3509.     cout << "\", the exception \"";
  3510.     Unicode::Cout(err.insert2);
  3511.     cout << "\" specified in method \"";
  3512.     Unicode::Cout(err.insert3);
  3513.     cout << "\" inherited from type \"";
  3514.     if (NotDot(err.insert4))
  3515.     {
  3516.         Unicode::Cout(err.insert4);
  3517.         cout << "/";
  3518.     }
  3519.     Unicode::Cout(err.insert5);
  3520.     cout << "\", is not the same as or a subclass of any exception in the throws clause of the overridden method \"";
  3521.     Unicode::Cout(err.insert6);
  3522.     cout << "\" declared in type \"";
  3523.     if (NotDot(err.insert7))
  3524.     {
  3525.         Unicode::Cout(err.insert7);
  3526.         cout << "/";
  3527.     }
  3528.     Unicode::Cout(err.insert8);
  3529.     cout << "\"";
  3530.  
  3531.     return;
  3532. }
  3533.  
  3534.  
  3535. void SemanticError::PrintABSTRACT_METHOD_WITH_BODY(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3536. {
  3537.     cout << "The declaration of the abstract or native method, \"";
  3538.     Unicode::Cout(err.insert1);
  3539.     cout << "\", must not contain a method body";
  3540.  
  3541.     return;
  3542. }
  3543.  
  3544.  
  3545. void SemanticError::PrintNON_ABSTRACT_METHOD_WITHOUT_BODY(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3546. {
  3547.     cout << "The declaration of the non-abstract and non-native method, \"";
  3548.     Unicode::Cout(err.insert1);
  3549.     cout << "\", must contain a method body";
  3550.  
  3551.     return;
  3552. }
  3553.  
  3554.  
  3555. void SemanticError::PrintSTATIC_OVERRIDE_ABSTRACT(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3556. {
  3557.     cout << "The static method \"";
  3558.     Unicode::Cout(err.insert1);
  3559.     cout << "\" cannot hide an abstract method of the same name declared in type \"";
  3560.     if (NotDot(err.insert2))
  3561.     {
  3562.         Unicode::Cout(err.insert2);
  3563.         cout << "/";
  3564.     }
  3565.     Unicode::Cout(err.insert3);
  3566.     cout << "\"";
  3567.  
  3568.     return;
  3569. }
  3570.  
  3571.  
  3572. void SemanticError::PrintSTATIC_OVERRIDE_ABSTRACT_EXTERNALLY(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3573. {
  3574.     cout << "In class \"";
  3575.     Unicode::Cout(err.insert1);
  3576.     cout << "\", the static method \"";
  3577.     Unicode::Cout(err.insert2);
  3578.     cout << "\", inherited from type \"";
  3579.     if (NotDot(err.insert3))
  3580.     {
  3581.         Unicode::Cout(err.insert3);
  3582.         cout << "/";
  3583.     }
  3584.     Unicode::Cout(err.insert4);
  3585.     cout << "\", cannot hide the abstract method \"";
  3586.     Unicode::Cout(err.insert5);
  3587.     cout << "\", inherited from type \"";
  3588.     if (NotDot(err.insert6))
  3589.     {
  3590.         Unicode::Cout(err.insert6);
  3591.         cout << "/";
  3592.     }
  3593.     Unicode::Cout(err.insert7);
  3594.     cout << "\"";
  3595.  
  3596.     return;
  3597. }
  3598.  
  3599.  
  3600. void SemanticError::PrintCIRCULAR_THIS_CALL(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3601. {
  3602.     cout << "The constructor \"";
  3603.     Unicode::Cout(err.insert1);
  3604.     cout << "\" may not directly or indirectly invoke itself";
  3605.  
  3606.     return;
  3607. }
  3608.  
  3609.  
  3610. void SemanticError::PrintINSTANCE_VARIABLE_IN_EXPLICIT_CONSTRUCTOR_INVOCATION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3611. {
  3612.     cout << "The instance variable \"";
  3613.     Unicode::Cout(err.insert1);
  3614.     cout << "\" declared in class \"";
  3615.     Unicode::Cout(err.insert2);
  3616.     cout << "\" is not accessible in an explicit constructor invocation";
  3617.  
  3618.     return;
  3619. }
  3620.  
  3621.  
  3622. void SemanticError::PrintINSTANCE_METHOD_IN_EXPLICIT_CONSTRUCTOR_INVOCATION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3623. {
  3624.     cout << "The instance method \"";
  3625.     Unicode::Cout(err.insert1);
  3626.     cout << "\" declared in this class, \"";
  3627.     Unicode::Cout(err.insert2);
  3628.     cout << "\", or one of its super classes, is not accessible in an explicit constructor invocation";
  3629.  
  3630.     return;
  3631. }
  3632.  
  3633.  
  3634. void SemanticError::PrintSYNTHETIC_VARIABLE_ACCESS(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3635. {
  3636.     cout << "Illegal attempt to access the synthetic field \"";
  3637.     Unicode::Cout(err.insert1);
  3638.     cout << "\" contained in class \"";
  3639.     if (NotDot(err.insert2))
  3640.     {
  3641.         Unicode::Cout(err.insert2);
  3642.         cout << "/";
  3643.     }
  3644.     Unicode::Cout(err.insert3);
  3645.     cout << "\"";
  3646.  
  3647.     return;
  3648. }
  3649.  
  3650.  
  3651. void SemanticError::PrintSYNTHETIC_METHOD_INVOCATION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3652. {
  3653.     cout << "Illegal attempt to invoke the synthetic method \"";
  3654.     Unicode::Cout(err.insert1);
  3655.     cout << "\" contained in class \"";
  3656.     if (NotDot(err.insert2))
  3657.     {
  3658.         Unicode::Cout(err.insert2);
  3659.         cout << "/";
  3660.     }
  3661.     Unicode::Cout(err.insert3);
  3662.     cout << "\"";
  3663.  
  3664.     return;
  3665. }
  3666.  
  3667.  
  3668. void SemanticError::PrintTHIS_IN_EXPLICIT_CONSTRUCTOR_INVOCATION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3669. {
  3670.     cout << "The expression \"";
  3671.     Unicode::Cout(err.insert1);
  3672.     cout << "\" may not be used in an explicit constructor invocation";
  3673.  
  3674.     return;
  3675. }
  3676.  
  3677.  
  3678. void SemanticError::PrintSUPER_IN_EXPLICIT_CONSTRUCTOR_INVOCATION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3679. {
  3680.     cout << "The expression \"";
  3681.     Unicode::Cout(err.insert1);
  3682.     cout << "\" may not be used in an explicit constructor invocation";
  3683.  
  3684.     return;
  3685. }
  3686.  
  3687.  
  3688. void SemanticError::PrintEXPRESSION_NOT_CONSTANT(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3689. {
  3690.     cout << "A constant expression is expected in this context";
  3691.  
  3692.     return;
  3693. }
  3694.  
  3695.  
  3696. void SemanticError::PrintUNCATCHABLE_METHOD_THROWN_CHECKED_EXCEPTION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3697. {
  3698.     cout << "The method \"";
  3699.     Unicode::Cout(err.insert1);
  3700.     cout << "\" can throw the checked exception \"";
  3701.     if (NotDot(err.insert2))
  3702.     {
  3703.         Unicode::Cout(err.insert2);
  3704.         cout << "/";
  3705.     }
  3706.     Unicode::Cout(err.insert3);
  3707.     cout << "\", but its invocation is neither enclosed in a try statement that can catch "
  3708.             "that exception nor in the body of a method or constructor that \"throws\" that exception";
  3709.  
  3710.     return;
  3711. }
  3712.  
  3713.  
  3714. void SemanticError::PrintUNCATCHABLE_CONSTRUCTOR_THROWN_CHECKED_EXCEPTION(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3715. {
  3716.     cout << "The constructor \"";
  3717.     Unicode::Cout(err.insert1);
  3718.     cout << "\" can throw the checked exception \"";
  3719.     if (NotDot(err.insert2))
  3720.     {
  3721.         Unicode::Cout(err.insert2);
  3722.         cout << "/";
  3723.     }
  3724.     Unicode::Cout(err.insert3);
  3725.     cout << "\", but its invocation is neither enclosed in a try statement that can catch "
  3726.             "that exception nor in the body of a method or constructor that \"throws\" that exception";
  3727.  
  3728.     return;
  3729. }
  3730.  
  3731.  
  3732. void SemanticError::PrintUNREACHABLE_CATCH_CLAUSE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3733. {
  3734.     cout << "This catch block may be unreachable because there is no exception "
  3735.             "whose type is assignable to \"";
  3736.     if (NotDot(err.insert1))
  3737.     {
  3738.         Unicode::Cout(err.insert1);
  3739.         cout << "/";
  3740.     }
  3741.     Unicode::Cout(err.insert2);
  3742.     cout << "\" that can be thrown during execution of the body of the try block";
  3743.  
  3744.     return;
  3745. }
  3746.  
  3747.  
  3748. void SemanticError::PrintUNREACHABLE_STATEMENT(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3749. {
  3750.     cout << "This statement is unreachable";
  3751.  
  3752.     return;
  3753. }
  3754.  
  3755.  
  3756. void SemanticError::PrintUNREACHABLE_STATEMENTS(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3757. {
  3758.     cout << "These statements are unreachable";
  3759.  
  3760.     return;
  3761. }
  3762.  
  3763.  
  3764. void SemanticError::PrintUNREACHABLE_CONSTRUCTOR_BODY(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3765. {
  3766.     cout << "The body of this constructor is unreachable because the last initializer block in this class does not complete normally";
  3767.  
  3768.     return;
  3769. }
  3770.  
  3771.  
  3772. void SemanticError::PrintBLOCKED_CATCH_CLAUSE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3773. {
  3774.     cout << "This catch block is unreachable: the exception \"";
  3775.     if (NotDot(err.insert1))
  3776.     {
  3777.         Unicode::Cout(err.insert1);
  3778.         cout << "/";
  3779.     }
  3780.     Unicode::Cout(err.insert2);
  3781.     cout << "\" was used in a previous catch clause in this try statement at location ";
  3782.     Unicode::Cout(err.insert3);
  3783.  
  3784.     return;
  3785. }
  3786.  
  3787.  
  3788. void SemanticError::PrintVARIABLE_NOT_DEFINITELY_ASSIGNED(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3789. {
  3790.     cout << "The variable \"";
  3791.     Unicode::Cout(err.insert1);
  3792.     cout << "\" may be accessed here before having been definitely assigned a value";
  3793.  
  3794.     return;
  3795. }
  3796.  
  3797.  
  3798. void SemanticError::PrintTYPED_METHOD_WITH_NO_RETURN(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3799. {
  3800.     cout << "The method \"";
  3801.     Unicode::Cout(err.insert1);
  3802.     cout << "\" must contain a return statement with an expression compatible with type \"";
  3803.     Unicode::Cout(err.insert2);
  3804.     cout << "\"";
  3805.  
  3806.     return;
  3807. }
  3808.  
  3809.  
  3810. void SemanticError::PrintDEFAULT_METHOD_NOT_OVERRIDDEN(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3811. {
  3812.     cout << "Method \"";
  3813.     Unicode::Cout(err.insert1);
  3814.     cout << "\" in class \"";
  3815.     if (NotDot(err.insert2))
  3816.     {
  3817.         Unicode::Cout(err.insert2);
  3818.         cout << "/";
  3819.     }
  3820.     Unicode::Cout(err.insert3);
  3821.     cout << "\" does not override the corresponding method with default access in class \"";
  3822.     if (NotDot(err.insert4))
  3823.     {
  3824.         Unicode::Cout(err.insert4);
  3825.         cout << "/";
  3826.     }
  3827.     Unicode::Cout(err.insert5);
  3828.     cout << "\"";
  3829.  
  3830.     return;
  3831. }
  3832.  
  3833.  
  3834. void SemanticError::PrintTYPE_NOT_IN_UNNAMED_PACKAGE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3835. {
  3836.     cout << "The file \"";
  3837.     Unicode::Cout(err.insert1);
  3838.     cout << ".class\" was found in directory \"";
  3839.     Unicode::Cout(err.insert2);
  3840.     cout << "\" specified in the CLASSPATH. However, that class file specifies a type associated with the named package \"";
  3841.     Unicode::Cout(err.insert3);
  3842.     cout << "\" instead of the unnamed package";
  3843. }
  3844.  
  3845.  
  3846. void SemanticError::PrintTYPE_IN_WRONG_PACKAGE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3847. {
  3848.     cout << "The type \"";
  3849.     Unicode::Cout(err.insert1);
  3850.     cout << "\" was found in package \"";
  3851.     Unicode::Cout(err.insert2);
  3852.     cout << "\". However, that type is associated with ";
  3853.     if (wcslen(err.insert3) == 0)
  3854.         cout << "the unnamed package";
  3855.     else
  3856.     {
  3857.         cout << "another named package, \"";
  3858.         Unicode::Cout(err.insert3);
  3859.         cout << "\"";
  3860.     }
  3861. }
  3862.  
  3863.  
  3864. void SemanticError::PrintTYPE_NAME_MISMATCH(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3865. {
  3866.     cout << "The name of the type specified, \"";
  3867.     if (NotDot(err.insert1))
  3868.     {
  3869.         Unicode::Cout(err.insert1);
  3870.         cout << "/";
  3871.     }
  3872.     Unicode::Cout(err.insert2);
  3873.     cout << "\", does not match the name found in the class file: \"";
  3874.     Unicode::Cout(err.insert3);
  3875.     cout << "\"";
  3876. }
  3877.  
  3878.  
  3879. void SemanticError::PrintONE_UNNAMED_PACKAGE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3880. {
  3881.     cout << "The type \"";
  3882.     Unicode::Cout(err.insert1);
  3883.     cout << "\" was found in directory \"";
  3884.     Unicode::Cout(err.insert2);
  3885.     cout << "\" specified in the CLASSPATH. It is accessible here only because, by default, this compiler uses "
  3886.             "one unnamed package. In a compiler that associates an unnamed package with each directory "
  3887.             "(as this compiler does with the +P option) this access would be illegal";
  3888.  
  3889.     return;
  3890. }
  3891.  
  3892.  
  3893.  
  3894. void SemanticError::PrintCOMPRESSED_ZIP_FILE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3895. {
  3896.     cout << "The file ";
  3897.     Unicode::Cout(err.insert1);
  3898.     cout << "(";
  3899.     Unicode::Cout(err.insert2);
  3900.     cout << "/";
  3901.     Unicode::Cout(err.insert3);
  3902.     cout << ") is in an unsupported compressed format. (Unzip and) Rezip \"";
  3903.     Unicode::Cout(err.insert1);
  3904.     cout << "\"";
  3905.  
  3906.     return;
  3907. }
  3908.  
  3909.  
  3910. void SemanticError::PrintINVALID_CLASS_FILE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3911. {
  3912.     cout << "The class file \"";
  3913.     if (NotDot(err.insert1))
  3914.     {
  3915.         Unicode::Cout(err.insert1);
  3916.         cout << "/";
  3917.     }
  3918.     Unicode::Cout(err.insert2);
  3919.     cout << ".class\" has an invalid format";
  3920.  
  3921.     return;
  3922. }
  3923.  
  3924.  
  3925. void SemanticError::PrintCANNOT_OPEN_CLASS_FILE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3926. {
  3927.     cout << "Unable to open file associated with type \"";
  3928.     if (NotDot(err.insert1))
  3929.     {
  3930.         Unicode::Cout(err.insert1);
  3931.         cout << "/";
  3932.     }
  3933.     Unicode::Cout(err.insert2);
  3934.     cout << "\"";
  3935.  
  3936.     return;
  3937. }
  3938.  
  3939.  
  3940. void SemanticError::PrintONE_ONE_FEATURE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3941. {
  3942.     cout << "This is a 1.1 feature";
  3943.  
  3944.     return;
  3945. }
  3946.  
  3947.  
  3948. void SemanticError::PrintSTATIC_NOT_INNER_CLASS(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3949. {
  3950.     cout << "The static class \"";
  3951.     if (NotDot(err.insert1))
  3952.     {
  3953.         Unicode::Cout(err.insert1);
  3954.         cout << "/";
  3955.     }
  3956.     Unicode::Cout(err.insert2);
  3957.     cout << "\" is not an inner class";
  3958.  
  3959.     return;
  3960. }
  3961.  
  3962.  
  3963. void SemanticError::PrintTYPE_NOT_INNER_CLASS(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3964. {
  3965.     cout << "The type \"";
  3966.     if (NotDot(err.insert1))
  3967.     {
  3968.         Unicode::Cout(err.insert1);
  3969.         cout << "/";
  3970.     }
  3971.     Unicode::Cout(err.insert2);
  3972.     cout << "\", is not an inner class that is immediately enclosed in type \"";
  3973.     if (NotDot(err.insert3))
  3974.     {
  3975.         Unicode::Cout(err.insert3);
  3976.         cout << "/";
  3977.     }
  3978.     Unicode::Cout(err.insert4);
  3979.     cout << "\"";
  3980.  
  3981.     return;
  3982. }
  3983.  
  3984.  
  3985. void SemanticError::PrintSUPER_TYPE_NOT_INNER_CLASS(ErrorInfo &err, LexStream *lex_stream, Control &control)
  3986. {
  3987.     cout << "The super type \"";
  3988.     if (NotDot(err.insert1))
  3989.     {
  3990.         Unicode::Cout(err.insert1);
  3991.         cout << "/";
  3992.     }
  3993.     Unicode::Cout(err.insert2);
  3994.     cout << "\" of this type, \"";
  3995.     if (NotDot(err.insert3))
  3996.     {
  3997.         Unicode::Cout(err.insert3);
  3998.         cout << "/";
  3999.     }
  4000.     Unicode::Cout(err.insert4);
  4001.     cout << "\", is not an inner class that is immediately enclosed in type \"";
  4002.     if (NotDot(err.insert5))
  4003.     {
  4004.         Unicode::Cout(err.insert5);
  4005.         cout << "/";
  4006.     }
  4007.     Unicode::Cout(err.insert6);
  4008.     cout << "\"";
  4009.  
  4010.     return;
  4011. }
  4012.  
  4013.  
  4014. void SemanticError::PrintSTATIC_FIELD_IN_INNER_CLASS(ErrorInfo &err, LexStream *lex_stream, Control &control)
  4015. {
  4016.     cout << "An inner class may not contain a static field that is not final";
  4017.  
  4018.     return;
  4019. }
  4020.  
  4021.  
  4022. void SemanticError::PrintSTATIC_METHOD_IN_INNER_CLASS(ErrorInfo &err, LexStream *lex_stream, Control &control)
  4023. {
  4024.     cout << "Inner class may not contain static method";
  4025.  
  4026.     return;
  4027. }
  4028.  
  4029.  
  4030. void SemanticError::PrintSTATIC_TYPE_IN_INNER_CLASS(ErrorInfo &err, LexStream *lex_stream, Control &control)
  4031. {
  4032.     cout << "The static type \"";
  4033.     Unicode::Cout(err.insert1);
  4034.     cout << "\" is enclosed in an inner class, \"";
  4035.     Unicode::Cout(err.insert2);
  4036.     cout << "\", located at ";
  4037.     Unicode::Cout(err.insert3);
  4038.  
  4039.     return;
  4040. }
  4041.  
  4042.  
  4043. void SemanticError::PrintSTATIC_INITIALIZER_IN_INNER_CLASS(ErrorInfo &err, LexStream *lex_stream, Control &control)
  4044. {
  4045.     cout << "This static initializer is enclosed in an inner class, \"";
  4046.     Unicode::Cout(err.insert1);
  4047.     cout << "\", located at ";
  4048.     Unicode::Cout(err.insert2);
  4049.  
  4050.     return;
  4051. }
  4052.  
  4053.  
  4054.  
  4055. void SemanticError::PrintINNER_CLASS_REFERENCE_TO_NON_FINAL_LOCAL_VARIABLE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  4056. {
  4057.     cout << "Invalid reference in inner class \"";
  4058.     if (NotDot(err.insert1))
  4059.     {
  4060.         Unicode::Cout(err.insert1);
  4061.         cout << "/";
  4062.     }
  4063.     Unicode::Cout(err.insert2);
  4064.     cout << "\" to a non-final local variable, \"";
  4065.     Unicode::Cout(err.insert3);
  4066.     cout << "\", declared in method \"";
  4067.     Unicode::Cout(err.insert4);
  4068.     cout << "\"";
  4069.  
  4070.     return;
  4071. }
  4072.  
  4073.  
  4074. void SemanticError::PrintINHERITANCE_AND_LEXICAL_SCOPING_CONFLICT_WITH_LOCAL(ErrorInfo &err, LexStream *lex_stream, Control &control)
  4075. {
  4076.     cout << "Ambiguous reference to field \"";
  4077.     Unicode::Cout(err.insert1);
  4078.     cout << "\" declared in (or inherited from) type \"";
  4079.     if (NotDot(err.insert2))
  4080.     {
  4081.         Unicode::Cout(err.insert2);
  4082.         cout << "/";
  4083.     }
  4084.     Unicode::Cout(err.insert3);
  4085.     cout << "\" but also declared in the enclosing method \"";
  4086.     Unicode::Cout(err.insert4);
  4087.     cout << "\". Explicit qualification is required";
  4088.  
  4089.     return;
  4090. }
  4091.  
  4092. void SemanticError::PrintINHERITANCE_AND_LEXICAL_SCOPING_CONFLICT_WITH_MEMBER(ErrorInfo &err, LexStream *lex_stream, Control &control)
  4093. {
  4094.     cout << "Ambiguous reference to member named \"";
  4095.     Unicode::Cout(err.insert1);
  4096.     cout << "\" inherited from type \"";
  4097.     if (NotDot(err.insert2))
  4098.     {
  4099.         Unicode::Cout(err.insert2);
  4100.         cout << "/";
  4101.     }
  4102.     Unicode::Cout(err.insert3);
  4103.     cout << "\" but also declared or inherited in the enclosing type \"";
  4104.     if (NotDot(err.insert4))
  4105.     {
  4106.         Unicode::Cout(err.insert4);
  4107.         cout << "/";
  4108.     }
  4109.     Unicode::Cout(err.insert5);
  4110.     cout << "\". Explicit qualification is required";
  4111.  
  4112.     return;
  4113. }
  4114.  
  4115.  
  4116. void SemanticError::PrintILLEGAL_THIS_FIELD_ACCESS(ErrorInfo &err, LexStream *lex_stream, Control &control)
  4117. {
  4118.     cout << "The type \"";
  4119.     if (NotDot(err.insert1))
  4120.     {
  4121.         Unicode::Cout(err.insert1);
  4122.         cout << "/";
  4123.     }
  4124.     Unicode::Cout(err.insert2);
  4125.     cout << "\" is either not an outer type of type \"";
  4126.     if (NotDot(err.insert3))
  4127.     {
  4128.         Unicode::Cout(err.insert3);
  4129.         cout << "/";
  4130.     }
  4131.     Unicode::Cout(err.insert4);
  4132.     cout << "\" or it is not accessible because this expression appears in a static region";
  4133.  
  4134.     return;
  4135. }
  4136.  
  4137.  
  4138. void SemanticError::PrintENCLOSING_INSTANCE_NOT_ACCESSIBLE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  4139. {
  4140.     cout << "An instance of \"";
  4141.     if (NotDot(err.insert1))
  4142.     {
  4143.         Unicode::Cout(err.insert1);
  4144.         cout << "/";
  4145.     }
  4146.     Unicode::Cout(err.insert2);
  4147.     Unicode::Cout(StringConstant::US__DO_);
  4148.     Unicode::Cout(StringConstant::US_this);
  4149.     cout << "\" is not accessible here";
  4150.     cout << ". In general, an enclosing instance is accessible only in the body of an instance method, "
  4151.             "constructor (after the explicit constructor invocation, if any), "
  4152.             "initializer block, or in the initializer expression of an instance variable";
  4153.     return;
  4154. }
  4155.  
  4156.  
  4157. void SemanticError::PrintZERO_DIVIDE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  4158. {
  4159.     cout << "Attempt to divide by zero";
  4160. }
  4161.  
  4162.  
  4163. void SemanticError::PrintVOID_TO_STRING(ErrorInfo &err, LexStream *lex_stream, Control &control)
  4164. {
  4165.     cout << "Attempt to convert an expression of type void into a String";
  4166. }
  4167.  
  4168.  
  4169. void SemanticError::PrintINVALID_ENCLOSING_INSTANCE(ErrorInfo &err, LexStream *lex_stream, Control &control)
  4170. {
  4171.     cout << "The super type of this type, \"";
  4172.     if (NotDot(err.insert1))
  4173.     {
  4174.         Unicode::Cout(err.insert1);
  4175.         cout << "/";
  4176.     }
  4177.     Unicode::Cout(err.insert2);
  4178.     cout << "\", is immediately enclosed in type \"";
  4179.     if (NotDot(err.insert3))
  4180.     {
  4181.         Unicode::Cout(err.insert3);
  4182.         cout << "/";
  4183.     }
  4184.     Unicode::Cout(err.insert4);
  4185.     cout << "\" which does not match the type of this primary expression, \"";
  4186.     if (NotDot(err.insert5))
  4187.     {
  4188.         Unicode::Cout(err.insert5);
  4189.         cout << "/";
  4190.     }
  4191.     Unicode::Cout(err.insert6);
  4192.     cout << "\"";
  4193.  
  4194.     return;
  4195. }
  4196.  
  4197.  
  4198. void SemanticError::PrintPRIVATE_ENCLOSED_CONSTRUCTOR(ErrorInfo &err, LexStream *lex_stream, Control &control)
  4199. {
  4200.     cout << "Access to a private enclosed constructor \"";
  4201.     Unicode::Cout(err.insert1);
  4202.     cout << "\" is currently unsupported... Awaiting clarification of language spec";
  4203.  
  4204.     return;
  4205. }
  4206.  
  4207.  
  4208. void SemanticError::PrintCONSTRUCTOR_FOUND_IN_ANONYMOUS_CLASS(ErrorInfo &err, LexStream *lex_stream, Control &control)
  4209. {
  4210.     cout << "An anonymous class cannot have a constructor";
  4211.  
  4212.     return;
  4213. }
  4214.